http://www.susangranger.com/
Susan Granger's review of "THE FANTASTICKS" (M.G.M./UNITED ARTISTS)
It's been more than 40 years since the two-act, fairy-tale musical by Tom Jones with lyrics by Harvey Schmidt opened off-Broadway at the tiny Sullivan Street Playhouse in Greenwich Village. Performed simply no scenery and few props, it relied primarily on the audience's imagination, much like "Our Town." In Michael Ritchie's screen version, it's set in rural Arizona, where a traveling carnival sets up in the vast wilderness. The plot still revolves around two fathers (Joel Grey, Brad Sullivan) who pretend to have an on-going feud in hopes that their respective children, Louisa and Matt (Jean Louisa Kelly, Joseph McIntyre), will behave as teenagers have throughout the centuries: rebel against them and fall in love. When this happens, the fathers must find a way to resolve their imaginary feud, so they conspire to have the carnival's handsome El Gallo (Jonathan Morris) pretend to be a bandit and kidnap Luisa so that Matt rescue her. What they don't figure into their plan is that Luisa might become infatuated with her abductor and that Matt might not be up to the task. What works is the simple story and evocative musical score - with "Try to Remember" now used as a finale. What doesn't work is opening up the concept to the big-screen; unlike "Oklahoma," for instance, the wind doesn't come sweeping down the plains. As a result, video sales will no doubt top theatrical revenues. Perhaps that's why this film has sat on the shelf for five years. On the Granger Movie Gauge of 1 to 10, "The Fantasticks" is a charming, nostalgic 7. It's timeless, old-fashioned family-fare, filled with hopes and dreams which bridge the generations and offer all of us a feeling of wondrous well-being. But is there still an audience for movie musicals?
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


 You don't need a mega-fast computer with lots of memory, to make really impressive huge zooms. We call them 'metabotniks'. And they load fast too, even on your mobiel phone. No waiting for a giant image to load in one go.
In the course of 2013 we started making gigapixel images as part of our cultural heritage and bookhistory research. The process was rather fiddly and needed some technical expertise and hefty-ish computers with sufficient memory. (at least 32GB of memory to do the really large ones). This is not accessible to general humanities researchers and we decided to make a web application that will make this kind of tool available to anyone with a web browser and a Dropbox account. Metabotnik was born.
Far from it! We are still frantically busy coding and fixing stuff and making plans on how it should work. Next major step is to add metadata editing and variable zoom level editing. Busy, busy!
A metabotnik is only visible to other users once you tick the 'Published' box. You can uncheck it at any time to hide it again.
Yes! When you make a metabotnik, the files are copied from your Dropbox on to the Metabotnik server. You can then free up space on your Dropbox again if you like. Watch out though: if you delete files in your own Dropbox and press the 'Re-sync Dropbox' button, the files will also be deleted from the Metabotnik server. Your generated metabotnik views will not be deleted until you delete the whole project.
Delete the file from your local Dropbox and then click on the 'Re-sync Dropbox' button in the edit screen of your project. Any files on the server which can not be found in your Dropbox will be deleted.
This feature has not been implemented yet, we are working on it.
Not yet. But this is a planned feature. We would like to track which parts of an image gets zoomed on by users, and log that. The resultant logs could be shown as a 'heat-map' overlayed on the original metabotnik so the owner could see what parts are popular and gets viewed a lot.
Some software (like Photoshop or the OS X Preview) do not rotate an image by actually moving the pixels around, but only set a property in the file saying: "rotate this file so many degrees when displaying it". When compliant software that understands this metadata displays the file it looks like it is rotated.  Sorry about that.


:::: Thursday, March 26th, 1.20pm @ Recital Room, Falmer House 120 ::::
The magnetic resonator piano (MRP) is an electromagnetically augmented acoustic grand piano which uses electromagnets to induce vibrations in the strings. The MRP is played from the piano keyboard using an optical scanner that measures the continuous position of every key. The instrument is capable of infinite sustain, crescendos from silence, harmonics, pitch bends and new timbres, all produced acoustically by the piano strings and soundboard without any external speakers.
This event will begin with a performance by music composed for, or adapted to, the magnetic resonator piano. A talk and workshop will follow the performance. The talk will present the design of the instrument, including how its evolution has been shaped by working with composers and performers. The MRP was first created in 2009, and underwent a significant design revision in 2011 in response to feedback from musicians. The talk will also discuss how other digital musical instrument creators can build a community of musicians around their instruments.
The workshop will explore techniques for composing and performing with the magnetic resonator piano, working directly with the instrument. Examples will be taken from recent pieces composed for MRP, and there will be an opportunity to try new ideas on the resonator system.
Biography:
Andrew McPherson is a Senior Lecturer in the Centre for Digital Music at Queen Mary University of London. With a background in electrical engineering and music, his research focuses on augmented acoustic instruments, new performance interfaces, and study of performer-instrument interaction. He did his undergraduate and Master’s work at MIT, completing his M.Eng. thesis in Barry Vercoe’s group at the MIT Media Lab. He completed his PhD in music composition in 2009 at the University of Pennsylvania. Before joining Queen Mary in 2011, he spent two years as a post-doctoral researcher in the Music Entertainment Technology Laboratory (MET-lab) at Drexel University.
In addition to the magnetic resonator piano, he is the creator of the TouchKeys multi-touch keyboard which launched in a successful Kickstarter campaign in 2013. More recently he has studied how musicians appropriate and misuse technology for creative purposes, creating a new digital musical instrument, the D-Box, specifically designed to be hacked and subverted by the performer using circuit bending techniques.


|
TrackracerAR
0.9.2
|
Interface for BuildDialogState More...
Public Member Functions | |
| void | StartNewTrack () |
| Creates new session data and transitions to BuildPaintState More... | |
| void | LoadTrack () |
| Transitions to BuildLoadState More... | |
| void | ObserveTrack () |
| Transitions to BuildObserveDialogState More... | |
| void | Recalibrate () |
| Transitions back to CalibrateState More... | |
Interface for BuildDialogState
| void IBuildDialogState.LoadTrack | ( | ) |
Transitions to BuildLoadState
Implemented in BuildDialogState.
| void IBuildDialogState.ObserveTrack | ( | ) |
Transitions to BuildObserveDialogState
Implemented in BuildDialogState.
| void IBuildDialogState.Recalibrate | ( | ) |
Transitions back to CalibrateState
Implemented in BuildDialogState.
| void IBuildDialogState.StartNewTrack | ( | ) |
Creates new session data and transitions to BuildPaintState
Implemented in BuildDialogState.


Leftists Vow to Cancel Nats' Kurt Suzuki for Donning MAGA Hat
Leftists on social media blew a collective fuse after Washington Nationals catcher Kurt Suzuki donned a MAGA hat during the White House’s welcoming ceremony for the World Series champions.
by Hannah BleauSuzuki, prior to speaking at the ceremony, put on a MAGA hat, prompting an embrace from President Donald Trump:
The catcher’s display of support for the president drew anger and feelings of betrayal from leftists on Twitter, some of whom suggested that he be canceled out or “banned from baseball” altogether.
 “Kurt Suzuki should be banned from baseball.  He willingly got b**t f****d by Donald Trump,” one user wrote.
“Shame on the @Nationals for appearing at the WH and normalizing this shitshow of presidency. Shame on Kurt Suzuki and Ryan Zimmerman, both of who have shown their true colors,” another wrote. “Disgusting. Kudos to all of the Nats players who refused to attend.”
“Kurt Suzuki I feel sick and sad,” one individual remarked. “As a longtime A’s fan, I proudly wore your hat. Never again! I rooted for the #Nationals in hopes you would get a ring. My mistake. MAGA pres is criminal- that’s how you’ll be remembered: #unmasked. Doolittle is a man of character.”
More:
Suzuki was not the only Nationals player to show support for the president. Ryan Zimmerman thanked Trump for “continuing to make America the greatest country in the world,” triggering leftists in droves:
“And the #ryanzimmerman Triggering topped 9.1 on the Prog Resistance Richter scale,” conservative author and commentator Michelle Malkin remarked:


Aussies close in on big win over Pakistan
Australia are seven wickets away from a perfect start to the test summer and inflicting a demoralising defeat on Pakistan.
On song with bat and ball, the Aussies are poised to take a 1-0 lead in the two-test series in Brisbane as soon as Sunday afternoon.
Three years ago at the Gabba, Pakistan almost pulled off the impossible by threatening to chase down a world-record 490 on the last two days.
But with another 276 runs required just to make Australia bat again and sunny skies predicted for Sunday and Monday, Pakistan would require an even bigger miracle this year.
Mitchell Starc looks to have re-found his groove with two late wickets on Saturday to reduce Pakistan to 3-64, while Pat Cummins also took one.
Starc's opening-spell wickets go with his four in the first innings, and come after a difficult Ashes series in which he had been overlooked for all but one test.

Cummins' wicket also came from an edge, although his ball that angled across Asad Shafiq was much more difficult for the batsman to negotiate.
"The process here is quite simple," Australian batsman Marnus Labuschagne said when asked of Sunday's plans.
"Keep bashing the wicket - it looks like Nathan (Lyon) is getting some spin out there, especially to the leftie.
"There's little bit of up and down so, hopefully, we can get a few hitting in the cracks and staying low."
With the bat, Australia will also be pleased.
David Warner hit his first century since the ball-tampering ban, while Joe Burns locked himself in as his opening partner.
Labuschagne looks an answer at No.3, after cracking his first test century on Saturday with a massive 185.
Matthew Wade also hit a half-century, with Travis Head and Steve Smith the only men in the top six to miss out.


httpd::doc(n) 1.1 "Tcl Web Server"
httpd::doc - File handling
TABLE OF CONTENTS
SYNOPSIS
DESCRIPTION
Public API
SEE ALSO
KEYWORDS
COPYRIGHT
package require httpd::doc ?1.1?
The package httpd::doc provides a domain for the serving of
urls from the filesystem. This is also the domain through which the
TML template facility is made available. It has additional tie-ins to
the packages httpd::cgi (CGI applications stored in the
fileststem) and httpd::dirlist (Directory listings as
virtual files).
- Access control
-
This package installs an access control callback,
DocAccessControl which uses the
package httpd::auth to determine if an request for an url
has to be denied or not. This method searches the directory
path to the file for .htaccess or .tclaccess files that specify
access controls. These are explained in the /access/ area
of the default web site distributed with the server.
- Doc_AddRoot virtual directory arg...
-
This commands adds a mapping from the url prefix virtual to the
directory in the filesystem.
Any additional arguments will be given as options and values to the
internal Url_PrefixInstall call registering virtual as a
new domain.
Note: The last implies that from httpd::url's point
of view each document root is a separate url domain.
- Doc_Root ?real arg...?
-
A convenient wrapper around Doc_AddRoot. It not only installs
the directory real as a document domain, but associates it with
the root of the url tree on this server, i.e. "/".
The command will return the name of the directory of that document
root if no argument is specified. Otherwise it will set this document
root and return the empty string.
All arguments coming after are additional options and values which are
given to Url_PrefixInstall.
- Doc_RegisterRoot virtual directory
-
Use this call to add a file system managed by any Domain Handler
(e.g. CGI for example) to this package. This registers the mapping
from urls in the domain to files, as required for Doc_Virtual.
- Doc_Include filename
-
Reads the contents of the file filename and substitutes them via
subst at the tcl stack level at which this procedure was called.
The result of the substitution is returned as the result of the
command. A relative path will be joined with the directory at the top
of the include stack in global variable page(includeStack).
- Doc_PublicHtml ?homedir?
-
En- and disables the handling of urls of the form "~user/a/b/..."
by mapping them to the subdirectory homedir of that users
account. The command will by default use the subdirectory
"public_html" if no directory was specified explicitly.
To disable the mapping invoke the command using the empty string for
the name of the subdirectory.
- Doc_Virtual sock curfile virtual
-
This command looks up the url virtual and returns the associated
path in the filesystem. It will return the empty string if
virtual is not managed by this package.
If virtual is a relative url, then curfile has to be
specified and will be treated as the path of the dcoument
containing the reference to virtual.
The argument sock represents the current connection. It is not
used by the command.
- Doc_Handle prefix path suffix sock
-
The main command for the handling of document urls.
Exported for use by other domains which have to handle
files.
The first three arguments specify the url to handle, and the file
associated with it. The last argument is the connection making the
request. The command assumes that all these pieces actually match up
with each other.
The command directs requests for directories always to the package
httpd::dirlist. Otherwise it will determine the mime-type of
the requested document and then either invoke a special handler for
that type if such present or directly reply with the contents of that
file if there is no special handler for the type.
If the path does not exist in the filesystem then it will try to
find an alternative it can serve. A not-found reply will be generated
only if that fails too.
It is this fallback mechanism which calls the template facility when
necessary.
The handler mechanism described above is also dependent on the
existence of appropriate file extension to mime type mapping in the
package httpd::mtype as otherwise special files will not be
recognized as such, i.e. the chosen mime type will be wrong.
If a file "mime.types" is present in the server library directory
(residence of all packages) it will be read automatically during
startup and used to set up a number of standard mappingsa to support
the type specific handlers exported by the various server packages.
httpd, httpd::auth, httpd::cgi, httpd::cookie, httpd::dirlist, httpd::doc_error, httpd::fallback, httpd::mtype, httpd::url
documents, filesystem, web server
Copyright © 2003 Andreas Kupries <andreas_kupries@users.sourceforge.net>


Qualifying duels with two Grands Prix remaining: Just one battle to be decided
by Matt GrettonThe 2019 F1 season is almost over and that means most qualifying battles between teammates have been decided. Just Carlos Sainz and Lando Norris remain in battle as the two McLaren drivers can't be separated.
Sainz leads the way going into the final two Grands Prix of the season meaning he needs to qualify ahead of Norris just once in either Brazil or Abu Dhabi to come out on top. The teammate duels are important in deciding which driver is best within a team. Check the list below!
With George Russell finishing ahead of Robert Kubica again ahead of the United States Grand Prix, it's still possible that the British driver can complete a 100% win record over his Williams teammate.
Bottas' pole position for the race in Austin means he has recorded one more pole position than Lewis Hamilton across the course of the season, but Hamilton remains on top in terms out of out-qualifying Bottas.
2019 F1 qualifying duels (19/21)
Mercedes
Hamilton 13-6 Bottas (decided)
Ferrari
Vettel 8-11 Leclerc (decided)
Red bull
Verstappen 6-1 Albon (decided)
Renault
Hulkenberg 7-12 Ricciardo (decided)
Hare
Magnussen 12-8 Grosjean (decided)
McLaren
Sainz 10-9 Norris
Racing point
Perez 16-3 Stroll (decided)
Alfa Romeo
Raikkonen 11-8 Giovinazzi (decided)
Toro Rosso
Kvyat 2-5 Gasly (decided)
Williams
Kubica 0-19 Russell (decided)


Try to answer the following questions within the time limit, incorrect scores will cost you 10 seconds off the clock! Timer starts with 60 seconds!


Updates
FAQ
Downloads
Features
Lolipop: Offline
A Customizable LVM.
Downloads
Well the project is still under development so they are no downloads.


{% extends 'main_app/base_index.html' %} {% block scripts %} {% endblock scripts %} {% block content %} New Patient Entry Form Important Note Only the Owner of the Contract has the access to use this functionality.If you aren't the owner, DO NOT PROCEED Go Back Add a New Patient {% csrf_token %} Patient's Name Patient's Disease Insured Amount Upload Medical Certificate Subscribe Newsletter Far far away, behind the word mountains, far from the countries Vokalia. {% endblock %}
Far far away, behind the word mountains, far from the countries Vokalia.


Look in the ../Windows/System32 folder for a file called "ntoskrnl.exe". If this file exists, it is at least an NT based system.
Now do a properties and examine the details for a product version.
exiftool ntoskrnl.exe
4.x: NT 4.x
5.0: Windows 2000
5.1: Windows XP
5.2: Windows 2003 Server or Windows XP-64-bit
6.0: Windows Vista
6.1: Windows 7
6.2; Windows 8
6.3: Windows 8.1
../Windows/System32/license.rtf
../Windows/System32/eula.txt
Windows/inf/layout.inf


Under development. Do not use. This simulator adds contacts to the cases of
an outbreak
object, using user-defined distributions for numbers and
duration of contacts. It returns an outbreaks
object with cases and
contacts, identifying entries in the linelist as cases or contacts, and links
as exposures or transmissions.
simulate_contacts(x, n_contacts, dist_time_to_contact, dist_duration)
| x | an |
|---|---|
| n_contacts | a vector of values to be used as average number of contacts; values will be drawn at random from this vector to determine the expected number of contacts for each new case |
| dist_time_to_contact | the distribution of the delay to new exposures, in days after the onset of symptoms |
| dist_duration | the distribution of duration of the exposure period after the first day, i.e. the time interval between the start and the end of the exposure window |
simulate_outbreak
## first simulate an outbreak ## (see example in ?simulate_outbreak) incubation <- c(0, 1, 1, 1, 1) # numbers = unscaled PMF infectious_period <- make_disc_gamma(10, 7) # distcrete object reporting <- function(x) dpois(x, 5) # PMF function set.seed(1) x <- simulate_outbreak(R = runif(100, 1, 3), # random values on [1;3] dist_incubation= incubation, dist_infectious_period = infectious_period, dist_reporting = reporting) ## simulate contacts: inputs ## exposure starts 0-2 days post onset time_to_contact = c(1, 1, 1) ## geom dist for duration of exposure duration <- function(x) dgeom(x, prob = .9) x_with_contacts <- simulate_contacts( x[1:10, ], n_contacts = 1:10, # 1 to 10 contacts dist_time_to_contact = time_to_contact, dist_duration = duration) ## check output class(x_with_contacts)#> [1] "outbreak" "data.frame"dim(x_with_contacts)#> [1] 72 9head(x_with_contacts)#> id source date_infection date_onset date_report R type #> 1 eLGzdD <NA> 0 3 12 1.95446 case #> 11 bhn89z eLGzdD NA NA NA NA non_case #> 12 OBTXKz eLGzdD NA NA NA NA non_case #> 14 mdHBGW eLGzdD NA NA NA NA non_case #> 16 ZqewV5 eLGzdD NA NA NA NA non_case #> 17 zOtsI8 eLGzdD NA NA NA NA non_case #> date_exposure_start date_exposure_end #> 1 0 0 #> 11 3 3 #> 12 3 3 #> 14 3 3 #> 16 3 3 #> 17 3 3plot(x_with_contacts)


Employee Data Service
Home
View/Edit
(current)
Charts
Employees
Roles
Departments
#
First
Last
Title
Department
Salary
Manager
Add
#
Title
Salary
Department
Add
#
Name
Add
title
×
First name
Last name
Title
Manager
title
×
Title
Salary
Department
title
×
Name
Error
×
Modal body text goes here.


{% extends 'users/mobile/pw_reset_form.html' %} {% from 'includes/mobile/common_macros.html' import errorlist %} {% block content %} {% if validlink %} {{ errorlist(form) }}
{% else %}{%- trans %} The password reset link was invalid, possibly because it has already been used. Please request a new password reset. {% endtrans -%}
{% endif %} {% endblock %}


Documentation
Table of Contents
- Installation
- Generating a Parser
- Using the Parser
- Grammar Syntax and Semantics
- Error Messages
- Locations
- Plugins API
- Compatibility
Installation
Node.js
To use the peggy
command, install Peggy globally:
$ npm install -g peggy
To use the JavaScript API, install Peggy locally:
$ npm install peggy
If you need both the peggy
command and the JavaScript API,
install Peggy both ways.
Browser
The easiest way to use Peggy from the browser is to pull the latest version from a CDN. Either of these should work:
<script src="https://unpkg.com/peggy"></script>
<script src="https://cdn.jsdelivr.net/npm/peggy"></script>
Both of those CDNs support pinning a version number rather than always taking the latest. Not only is that good practice, it will save several redirects, improving performance. See their documentation for more information:
When your document is done loading, there will be a global peggy
object.
Generating a Parser
Peggy generates parser from a grammar that describes expected input and can specify what the parser returns (using semantic actions on matched parts of the input). Generated parser itself is a JavaScript object with a simple API.
Command Line
To generate a parser from your grammar, use the peggy
command:
$ peggy arithmetics.pegjs
This writes parser source code into a file with the same name as the grammar file but with “.js” extension. You can also specify the output file explicitly:
$ peggy -o arithmetics-parser.js arithmetics.pegjs
If you omit both input and output file, standard input and standard output are used.
By default, the generated parser is in the Node.js module format. You can
override this using the --format
option.
You can tweak the generated parser with several options:
--allowed-start-rules
- Comma-separated list of rules the parser will be allowed to start parsing from (default: the first rule in the grammar).
--cache
- Makes the parser cache results, avoiding exponential parsing time in pathological cases but making the parser slower.
--dependency
- Makes the parser require a specified dependency (can be specified multiple times).
--export-var
- Name of a global variable into which the parser object is assigned to when no module loader is detected.
--extra-options
- Additional options (in JSON format) to pass to
peg.generate
. --extra-options-file
- File with additional options (in JSON format) to pass to
peg.generate
. --format
- Format of the generated parser:
amd
,commonjs
,globals
,umd
,es
(default:commonjs
). --plugin
- Makes Peggy use a specified plugin (can be specified multiple times).
--trace
- Makes the parser trace its progress.
JavaScript API
In Node.js, require the Peggy parser generator module:
const peggy = require("peggy");
or:
import * as peggy from "peggy";
For use in browsers, include the Peggy library in your web page or application using
the <script>
tag. If Peggy detects an AMD loader, it will
define itself as a module, otherwise the API will be available in the
peg
global object.
To generate a parser, call the peggy.generate
method and pass your
grammar as a parameter:
const parser = peggy.generate("start = ('a' / 'b')+");
The method will return generated parser object or its source code as a string
(depending on the value of the output
option — see below). It will
throw an exception if the grammar is invalid. The exception will contain a
message
property with more details about the error.
You can tweak the generated parser by passing a second parameter with an
options object to peg.generate
. The following options are
supported:
allowedStartRules
- Rules the parser will be allowed to start parsing from (default: the first rule in the grammar).
cache
- If
true
, makes the parser cache results, avoiding exponential parsing time in pathological cases but making the parser slower (default:false
). dependencies
- Parser dependencies, the value is an object which maps variables used to
access the dependencies in the parser to module IDs used to load them; valid
only when
format
is set to"amd"
,"commonjs"
,"es"
, or"umd"
. Dependencies variables will be available in both the global initializer and the per-parse initializer. Unless the parser is to be generated in different formats, it is recommended to rather import dependencies from within the global initializer (default:{}
). exportVar
- Name of a global variable into which the parser object is assigned to when
no module loader is detected; valid only when
format
is set to"globals"
or"umd"
(default:null
). format
- format of the generated parser (
"amd"
,"bare"
,"commonjs"
,"es"
,"globals"
, or"umd"
); valid only whenoutput
is set to"source"
(default:"bare"
). grammarSource
- any object that represent origin of the input grammar. The CLI will set
it to a string with the path to the file; parsers in network applications
might use the socket and so on. The supplied object will be available at key
source
in the location objects, that returned by thelocation()
API function (default:undefined
). output
- If set to
"parser"
, the method will return generated parser object; if set to"source", it will return parser source code as a string (default: "parser"
). plugins
- Plugins to use. See the [Plugins API](#plugins-api) section.
trace
- Makes the parser trace its progress (default:
false
).
Using the Parser
To use the generated parser, call its parse
method and pass an input string as a parameter. The method will return a parse
result (the exact value depends on the grammar used to generate the parser) or
throw an exception if the input is invalid. The exception will contain
location
, expected
, found
,
message
, and diagnostic
properties with more details about the error. The error
will have a format(SourceText[])
function, to which you pass an array
of objects that look like { source: grammarSource, text: string }
; this
will return a nicely-formatted error suitable for human consumption.
parser.parse("abba"); // returns ["a", "b", "b", "a"]
parser.parse("abcd"); // throws an exception
You can tweak parser behavior by passing a second parameter with an options
object to the parse
method. The following options are
supported:
startRule
- Name of the rule to start parsing from.
tracer
- Tracer to use.
...
(any others)- Made available in the
options
variable
As you can see above, parsers can also support their own custom options. For example:
const parser = peggy.generate(`
{
// options are available in the per-parse initializer
console.log(options.validWords); // outputs "[ 'boo', 'baz', 'boop' ]"
}
validWord = @word:$[a-z]+ &{ return options.validWords.includes(word) }
`);
const result = parser.parse("boo", {
validWords: [ "boo", "baz", "boop" ]
});
console.log(result); // outputs "boo"
Grammar Syntax and Semantics
The grammar syntax is similar to JavaScript in that it is not line-oriented
and ignores whitespace between tokens. You can also use JavaScript-style
comments (// ...
and /* ... */
).
Let's look at example grammar that recognizes simple arithmetic expressions
like 2*(3+4)
. A parser generated from this grammar computes their
values.
start
= additive
additive
= left:multiplicative "+" right:additive { return left + right; }
/ multiplicative
multiplicative
= left:primary "*" right:multiplicative { return left * right; }
/ primary
primary
= integer
/ "(" additive:additive ")" { return additive; }
integer "integer"
= digits:[0-9]+ { return parseInt(digits.join(""), 10); }
On the top level, the grammar consists of rules (in our example,
there are five of them). Each rule has a name (e.g.
integer
) that identifies the rule, and a parsing
expression (e.g. digits:[0-9]+ { return parseInt(digits.join(""),
10); }
) that defines a pattern to match against the input text and
possibly contains some JavaScript code that determines what happens when the
pattern matches successfully. A rule can also contain human-readable
name that is used in error messages (in our example, only the
integer
rule has a human-readable name). The parsing starts at the
first rule, which is also called the start rule.
A rule name must be a JavaScript identifier. It is followed by an equality sign (“=”) and a parsing expression. If the rule has a human-readable name, it is written as a JavaScript string between the rule name and the equality sign. Rules need to be separated only by whitespace (their beginning is easily recognizable), but a semicolon (“;”) after the parsing expression is allowed.
The first rule can be preceded by a global initializer and/or a per-parse initializer, in that order. Both are pieces of JavaScript code in double curly braces (“{{” and “}}”) and single curly braces (“{” and “}”) respectively. All variables and functions defined in both initializers are accessible in rule actions and semantic predicates. Curly braces in both initializers code must be balanced.
The global initializer is executed once and only once, when the
generated parser is loaded (through a require
or an
import
statement for instance). It is the ideal location to
require, to import, to declare constants, or to declare utility functions to be used in rule actions
and semantic predicates.
The per-parse initializer is called before the generated parser
starts parsing. The code inside the per-parse initializer can access
the input string and the options passed to the parser using the
input
variable and the options
variable respectively.
It is the ideal location to create data structures that are unique to each
parse or to modify the input before the parse.
Let's look at the example grammar from above using a global initializer and a per-parse initializer:
{{
function makeInteger(o) {
return parseInt(o.join(""), 10);
}
}}
{
if (options.multiplier) {
input = "(" + input + ")*(" + options.multiplier + ")";
}
}
start
= additive
additive
= left:multiplicative "+" right:additive { return left + right; }
/ multiplicative
multiplicative
= left:primary "*" right:multiplicative { return left * right; }
/ primary
primary
= integer
/ "(" additive:additive ")" { return additive; }
integer "integer"
= digits:[0-9]+ { return makeInteger(digits); }
The parsing expressions of the rules are used to match the input text to the grammar. There are various types of expressions — matching characters or character classes, indicating optional parts and repetition, etc. Expressions can also contain references to other rules. See detailed description below.
If an expression successfully matches a part of the text when running the generated parser, it produces a match result, which is a JavaScript value. For example:
- An expression matching a literal string produces a JavaScript string containing matched text.

The match results propagate through the rules when the rule names are used in expressions, up to the start rule. The generated parser returns start rule's match result when parsing is successful.
One special case of parser expression is a parser action — a piece of JavaScript code inside curly braces (“{” and “}”) that takes match results of some of the the preceding expressions and returns a JavaScript value. This value is considered match result of the preceding expression (in other words, the parser action is a match result transformer).
In our arithmetics example, there are many parser actions. Consider the
action in expression digits:[0-9]+ { return parseInt(digits.join(""), 10);
}
. It takes the match result of the expression [0-9]+, which is an array
of strings containing digits, as its parameter. It joins the digits together to
form a number and converts it to a JavaScript number
object.
Parsing Expression Types
There are several types of parsing expressions, some of them containing subexpressions and thus forming a recursive structure:
"literal"
'literal'-
Match exact literal string and return it. The string syntax is the same as in JavaScript. Appending
i
right after the literal makes the match case-insensitive. .
-
Match exactly one character and return it as a string.
[characters]
-
Match one character from a set and return it as a string. The characters in the list can be escaped in exactly the same way as in JavaScript string. The list of characters can also contain ranges (e.g.
[a-z]
means “all lowercase letters”). Preceding the characters with^
inverts the matched set (e.g.[^a-z]
means “all character but lowercase letters”). Appendingi
right after the literal makes the match case-insensitive. rule
-
Match a parsing expression of a rule recursively and return its match result.
( expression )
-
Match a subexpression and return its match result.
expression *
-
Match zero or more repetitions of the expression and return their match results in an array. The matching is greedy, i.e. the parser tries to match the expression as many times as possible. Unlike in regular expressions, there is no backtracking.
expression +
-
Match one or more repetitions of the expression and return their match results in an array. The matching is greedy, i.e. the parser tries to match the expression as many times as possible. Unlike in regular expressions, there is no backtracking.
expression ?
-
Try to match the expression. If the match succeeds, return its match result, otherwise return
null
. Unlike in regular expressions, there is no backtracking. & expression
-
Try to match the expression. If the match succeeds, just return
undefined
and do not consume any input, otherwise consider the match failed. ! expression
-
Try to match the expression. If the match does not succeed, just return
undefined
and do not consume any input, otherwise consider the match failed. & { predicate }
-
This is a positive assertion. No input is consumed.
The predicate should be JavaScript code, and it's executed as a function. Curly braces in the predicate must be balanced.
The predicate should
return
a boolean value. If the result is truthy, it's match result isundefined
, otherwise the match is considered failed.The predicate has access to all variables and functions in the Action Execution Environment.
! { predicate }
-
This is a negative assertion. No input is consumed.
The predicate should be JavaScript code, and it's executed as a function. Curly braces in the predicate must be balanced.
The predicate should
return
a boolean value. If the result is falsy, it's match result isundefined
, otherwise the match is considered failed.The predicate has access to all variables and functions in the Action Execution Environment.
$ expression
-
Try to match the expression. If the match succeeds, return the matched text instead of the match result.
If you need to return the matched text in an action, use the
text()
function. label : expression
-
Match the expression and remember its match result under given label. The label must be a JavaScript identifier, but not in the list of reserved words. By default this is a list of JavaScript reserved words, but plugins can change it.
Labeled expressions are useful together with actions, where saved match results can be accessed by action's JavaScript code.
@ ( label : )? expression
-
Match the expression and if the label exists, remember its match result under given label. The label must be a JavaScript identifier if it exists, but not in the list of reserved words. By default this is a list of JavaScript reserved words, but plugins can change it.
Return the value of this expression from the rule, or "pluck" it. You may not have an action for this rule. The expression must not be a semantic predicate (
&{ predicate }
or!{ predicate }
). There may be multiple pluck expressions in a given rule, in which case an array of the plucked expressions is returned from the rule.Pluck expressions are useful for writing terse grammars, or returning parts of an expression that is wrapped in parentheses.
expression1 expression2 ... expressionn
-
Match a sequence of expressions and return their match results in an array.
expression { action }
-
If the expression matches successfully, run the action, otherwise consider the match failed.
The action should be JavaScript code, and it's executed as a function. Curly braces in the action must be balanced.
The action should
return
some value, which will be used as the match result of the expression.The action has access to all variables and functions in the Action Execution Environment.
expression1 / expression2 / ... / expressionn
-
Try to match the first expression, if it does not succeed, try the second one, etc. Return the match result of the first successfully matched expression. If no expression matches, consider the match failed.
Action Execution Environment
Actions and predicates have these variables and functions available to them.
All variables and functions defined in the initializer or the top-level initializer at the beginning of the grammar are available.
Note, that all functions and variables, described below, are unavailable in the global initializer.
Labels from preceding expressions are available as local variables, which will have the match result of the labelled expressions.
A label is only available after its labelled expression is matched:
rule = A:('a' B:'b' { /* B is available, A is not */ } )
A label in a sub-expression is only valid within the sub-expression:
rule = A:'a' (B:'b') (C:'b' { /* A and C are available, B is not */ })
input
is a parsed string that was passed to theparse()
method.options
is a variable that contains the parser options. That is the same object that was passed to theparse()
method.error(message, where)
will report an error and throw an exception.where
is optional; the default is the value oflocation()
.expected(message, where)
is similar toerror
, but reportsExpected message but "other" found.
where
other
is, by default, the character in thelocation().start.offset
position.location()
returns an object with the information about the parse position. Refer to the corresponding section for the details.range()
is similar tolocation()
, but returns an object with offsets only. Refer to the "Locations" section for the details.offset()
returns only the start offset, i.e.location().start.offset
. Refer to the "Locations" section for the details.text()
returns the source text betweenstart
andend
(which will be""
for predicates). Instead of using that function as a return value for the rule consider using the$
operator.
Parsing Lists
One of the most frequent questions about Peggy grammars is how to parse a delimited list of items. The cleanest current approach is:
list = head:word tail:(_ "," _ @word)* { return [head, ...tail); }
word = $[a-z]i+
_ = [ \t]*
Note that the @
in the tail section plucks the word out of the
parentheses, NOT out of the rule itself.
Error Messages
As described above, you can annotate your grammar rules with human-readable names that will be used in error messages. For example, this production:
integer "integer"
= digits:[0-9]+
will produce an error message like:
Expected integer but "a" found.
when parsing a non-number, referencing the human-readable name "integer." Without the human-readable name, Peggy instead uses a description of the character class that failed to match:
Expected [0-9] but "a" found.
Aside from the text content of messages, human-readable names also have a subtler effect on where errors are reported. Peggy prefers to match named rules completely or not at all, but not partially. Unnamed rules, on the other hand, can produce an error in the middle of their subexpressions.
For example, for this rule matching a comma-separated list of integers:
seq
= integer ("," integer)*
an input like 1,2,a produces this error message:
Expected integer but "a" found.
But if we add a human-readable name to the seq production:
seq "list of numbers"
= integer ("," integer)*
then Peggy prefers an error message that implies a smaller attempted parse tree:
Expected end of input but "," found.
There are two classes of errors in Peggy:
SyntaxError
: Syntax errors, found during parsing the input. This kind of errors can be thrown both during grammar parsing and during input parsing. Although name is the same, errors of each generated parser (including Peggy parser itself) has its own unique class.GrammarError
: Grammar errors, found during construction of the parser. These errors can be thrown only in the parser generation phase. This error signals a logical mistake in the grammar, such as having two rules with the same name in one grammar, etc.
Both of these errors have the format()
method that takes an array of mappings from source to grammar text:
let source = ...;
try {
peggy.generate(text, { grammarSource: source, ... }); // throws SyntaxError or GrammarError
parser.parse(input, { grammarSource: source2, ... }); // throws SyntaxError
} catch (e) {
if (typeof e.format === "function") {
console.log(e.format([
{ source, text },
{ source: source2, text: input },
...
]));
} else {
throw e;
}
}
Messages generated by format()
look like this
Error: Possible infinite loop when parsing (left recursion: start -> proxy -> end -> start)
--> .\recursion.pegjs:1:1
|
1 | start = proxy;
| ^^^^^
note: Step 1: call of the rule "proxy" without input consumption
--> .\recursion.pegjs:1:9
|
1 | start = proxy;
| ^^^^^
note: Step 2: call of the rule "end" without input consumption
--> .\recursion.pegjs:2:11
|
2 | proxy = a:end { return a; };
| ^^^
note: Step 3: call itself without input consumption - left recursion
--> .\recursion.pegjs:3:8
|
3 | end = !start
| ^^^^^
Locations
During the parsing you can access to the information of the current parse location,
such as offset in the parsed string, line and column information. You can get this
information by calling location()
function, which returns you the following object:
{
source: options.grammarSource,
start: { offset: 23, line: 5, column: 6 },
end: { offset: 25, line: 5, column: 8 }
}
source
is an any object that was supplied in the grammarSource
option in
the parse()
call. That object can be used to hold reference to the origin of
the grammar, for example, it can be a filename. It is recommended that this
object have a toString()
implementation that returns meaningful string,
because that string will be used when getting formatted error representation
with e.format()
.
If source
is null
or undefined
it doesn't appear in the formatted messages.
The default value for source
is undefined
.
For actions, start
refers to the position at the beginning of the preceding
expression, and end
refers to the position after the end of the preceding
expression.
For semantic predicates, start
and end
are equal, denoting the location where
the predicate is evaluated.
For the per-parse initializer, the location is the start of the input, i.e.
{
source: options.grammarSource,
start: { offset: 0, line: 1, column: 1 },
end: { offset: 0, line: 1, column: 1 }
}
offset
is a 0-based character index within the source text.
line
and column
are 1-based indices.
The line number is incremented each time the parser finds an end of line sequence in the input.
Line and column are somewhat expensive to compute, so if you just need the
offset, there's also a function offset()
that returns just the start offset,
and a function range()
that returns the object:
{
source: options.grammarSource,
start: 23,
end: 25
}
(i.e. difference from the location()
result only in type of start
and end
properties, which contain just an offset instead of the Location
object.)
All notes about values for location()
object is also applicable to the range()
and offset()
calls.
Currently, Peggy only works with the Basic Multilingual Plane (BMP) of Unicode. This means that all offsets are measured in UTF-16 code units. If you try to parse characters outside this Plane (for example, emoji, or any surrogate pairs), you may get an offset inside a code point.
Changing this behavior may be a breaking change and will not to be done before Peggy 2.0. You can join to the discussion for this topic on the GitHub Discussions page.
Plugins API
A plugin is an object with the use(config, options)
method. That method will be
called for all plugins in the options.plugins
array, supplied to the generate()
method.
use
accepts these parameters:
config
Object with the following properties:
parser
Parser
object, by default thepeggy.parser
instance. That object will be used to parse the grammar. Plugin can replace this objectpasses
-
Mapping
{ [stage: string]: Pass[] }
that represents compilation stages that would applied to the AST, returned by theparser
object. That mapping will contain at least the following keys:check
— passes that check AST for correctness. They shouldn't change the ASTtransform
— passes that performs various optimizations. They can change the AST, add or remove nodes or their propertiesgenerate
— passes used for actual code generating
A plugin that implement a pass usually should push it to the end of one of that arrays. Pass is a simple function with signature
pass(ast, options)
:ast
— the AST created by theconfig.parser.parse()
methodoptions
— compilation options passed to thepeggy.compiler.compile()
method. If parser generation is started becausegenerate()
function was called that is also an options, passed to thegenerate()
method
reservedWords
-
String array with a list of words that shouldn't be used as label names. This list can be modified by plugins. That property is not required to be sorted or not contain duplicates, but it is recommend to remove duplicates.
Default list contains JavaScript reserved words, and can be found in the
peggy.RESERVED_WORDS
property.
options
generate()
method. A best practice for
a plugin would look for its own options under a <plugin_name>
key.Compatibility
Both the parser generator and generated parsers should run well in the following environments:
- Node.js 10+
- Internet Explorer 9+
- Edge
- Firefox
- Chrome
- Safari
- Opera


Scastie is Scala + SBT in your browser! You can use any version of Scala, or even alternate backends such as Dotty, Scala.js, Scala Native, and Typelevel Scala. You can use any published library. You can save and share Scala programs/builds with anybody.


RNA content of RNA-protein assemblies in yeast
Edward Wallace<EMAIL_ADDRESS>September 17, 2020
Introduction
The aim is to ﬁnd out which RNAs are sequestered in RNA-protein assemblies, by extracting both supernatant and pellet of
100,000g fractionated lysate.
Prepare
- soluble RNA buﬀer (SRB; 20mM HEPES-KOH pH7.4, 120mM KCl, 2mM EDTA, 0.2mM DTT, 1:100 Protease
Inhibitors cocktail IV, 1:100 RNAsin plus.) Make stock of salt and buﬀer, then chill and add DTT and
inhibitors immediately before use.
- insoluble RNA buﬀer (IRB; 20mM HEPES-KOH pH7.4, 120mM KCl, 10mM EDTA, 2% Sarkosyl, 2mM DTT,
1:100 Protease Inhibitors cocktail IV, 1:100 RNAsin plus.).
- 10X soluble additive buﬀer (SAB; 20% Sarkosyl, 100mM EDTA).
- Prepare appropriate numbers of safe-lok tubes (2X number of samples) loaded with 7mm steel balls, racked
in LN, labeled on sides and top. Also, labeled tubes for all steps of protocol.
- Waterbath at desired temperature, ice, chilled centrifuge rotors, etc.
CAUTION: Phenol and Phenol:Chloroform are extremely dangerous, causing chemical burns, and must be handled in a
fume hood.
Sample growth and lysis
-
1.
- Grow up several cultures of yeast (BY4741) to
cells/mL ()
at 30C,
in 100ml media in a 250ml ﬂask.
-
2.
- Transfer
cells to a 50mL conical tube (50 mL of a
cells/mL culture).
-
3.
- Spin at 2500g for 30s. Gently decant and discard supernatant.
-
4.
- For short heat shock treatment, hold tube with pellet in waterbath at desired temperature for desired time.
-
5.
- Resuspend pellet in 1 ml ice-cold SPB, on ice. Transfer to 1.5mL tube, centrifuge 1min, 5,000g, 4C.
Discard supernatant.
-
6.
- Resuspend pellet in 150 L
ice-cold SPB, on ice.
-
7.
- Drip
of resuspended pellet onto upper wall of 2 tubes containing steel ball. 1 tube will be used for fractionation, the
other for total RNA extraction. Goal is to get a nugget of frozen material on the wall, and to avoid dripping
the material around the ball and thus freezing the ball to the bottom of the tube; having some LN2 remaining
in the tube helps.
-
8.
- Place tubes at -80C;
when all LN2 has boiled out of tube (listen – if any popping or hissing, keep waiting), snap tube closed
carefully, away from other tubes. Keep in LN2. (Any remaining LN2 in tube will cause tube to explode open
and ﬁre the stainless steel ball into your iPad, brain, colleague, or other important equipment.)
-
9.
- Rack the tube into the PTFE 2mL tube adaptor for the Retsch Mixer Mill MM400 (Retsch #22.008.0005) and
submerge the entire assembly in LN2. Agitate for
seconds at 30 Hz in a Retsch Mixer Mill MM400, returning sample holder to LN2 between sessions. Complete
lysis produces ﬁne snowy powder in the tube.
-
10.
- Remove sample tubes from LN2 and pop the caps to relieve pressure. Add 400 L
SPB to each tube, and extract ball with a magnet. We rinse balls in methanol and store in 50% ethanol.
Soluble fraction extraction
-
11.
- Spin at 3000g for 30 seconds (clariﬁcation step) to remove whole cells and very large aggregates.
-
12.
- Decant clariﬁed liquid into a 1.5mL microcentrifuge tube. If desired, keep the pellet and process it alongside
the insoluble fraction; this end product is the unclariﬁed fraction. For total RNA samples, skip next spin and
move to step 16.
-
13.
- Spin at 100,000g for 20 minutes (ﬁxed-angle TLA-55 rotor at 40,309 rpm, 4C,
in a Beckman Coulter Optimax tabletop ultracentrifuge).
-
14.
- Decant supernatant into a 1.5mL microcentrifuge tube: this is the soluble fraction.
-
15.
- Take 10ul aliquot of soluble fraction and mix with Laemmli buﬀer; use this to run a protein gel and assess
protein integrity.
-
16.
- Mix soluble fraction with 1/10 vol SAB (Sarkosyl/EDTA), and equal volume Phenol, to denature proteins
and begin RNA extraction.
Insoluble fraction extraction
-
17.
- Violently snap pellet to clear remaining liquid.
-
18.
- Add 500 L
soluble RNA buﬀer (SRB) and vortex violently. (The pellet may not resuspend; that’s ﬁne.)
-
19.
- Spin at 100,000g for 20 minutes.
-
20.
- Discard supernatant, clear residual liquid with a hard snap.
-
21.
- Add 500 L
insoluble RNA buﬀer (IRB). Vortex brieﬂy.
-
22.
- Add equal volume Phenol pH 8, vortex until pellet dissolves, begin RNA extraction.
RNA extraction
Extract using standard phenol:chloroform method.
-
23.
- Having mixed equal volumes of aqueous solution with Phenol, ensure tubes are vortexed thoroughly.
-
24.
- Spin at 14,000g for 2mins at 4C.
-
25.
- Transfer aqueous phase (roughly 200L)
to new 1.5ml tube (labeled tube N), avoiding cloudy interphase and lipids on top. Add 250L
SPB to previous tube (labeled tube A) and vortex tube A for 5mins.
-
26.
 Vortex for 3 mins, then spin 2mins at 14,000g and
transfer aqueous phase from tube A to tube N. Discard tube A.
-
27.
- Repeat extraction on tube N: mix with equal volume Phenol:Chloroform pH 4.5, vortex 30s, 14,000g for 2mins,
remove aqueous phase to new tube. Repeat until interphase is no longer cloudy.
-
28.
- To ﬁnal aqueous sample add 1/10 vol ammonium Acetate, 1.5 vol 100% EtOH, and 1L
GlycoBlue (use a master mix!). Mix gently, precipitate overnight at -20C.
-
29.
- Remove the sample from freezer. Cold spin (4C)
for 15 mins at 14,000g.
-
30.
- Thoroughly remove ethanol from pellet, and add 700L
80% ethanol. Cold spin for 2 minutes at 14,000g. If desired, repeat the ethanol wash and cold spin. This
removes all traces of salt, detergent, etc.
-
31.
- Dry pellets thoroughly, i.e., pipette oﬀ ethanol, removing all liquid. If necessary, dry with the tubes open on a
37C heat
block (if the RNA sample is pure, this should not degrade the RNA). Resuspend pellet in 50 L
HO.
-
32.
- To check the quality of the RNA, pour a 1% agarose-TBE gel on RNA-free equipment, and run using NEB RNA
loading dye. Heat loading dye and HO
to 95C for
5 minutes, and then cool, to reduce the possibility of contamination. Mix 1L
sample, 10L
1X loading dye for each well. Perform a 2X serial dilution of the sample for more precise quantiﬁcation.


Read and digest the piece Collapsed Puffin, below. Then reread it and redigest it. If necessary, rereread it and reredigest it. Now, using a sharpened pencil and a sheet of foolscap paper, write a variation of the piece from the point of view of the companion, Squiffy. You should aim to address the following matters:
1. Why do you think the narrator keeps nagging Squiffy regarding his goggles, ear-corks, nasal icicles, and furry boots?
2. Which of the pair do you think is the pilot of the chopper?
3. Does the collapsed puffin actually exist or is it an hallucination borne of cold, exhaustion, or even piblokto?
4. Do you think the narrator's love of puffins, guillemots, auks, and bonxies is sincere and unreserved, or is it an affectation?
5. Can you recall any nursery rhymes in which bonxies appear?
When you have finished, turn over the piece of foolscap paper and, on the reverse, write an even more compelling variation from the point of view of the collapsed puffin.


Updater For Notice Board App
If the update does not start automatically,
click here
to manually download the .apk file


Now you can only see how many kills you got with your best weapon, it would be nice to see how many kills you get with each weapon.
see attachment.
juress
Theme Developer
You'll have to wait for Brain's answer, but I don't think is technically possible, sorry.
ORFK
Global Moderator
would be possible with data from bf3stats.
but my request to include the "best vehicle" to the battlereport was rejected too, so i don't think brain would include, release this request.
BrainFooLong
Administrator
Sorry, there no plans to implement this.
If you really interested on all possible details for a report goto bf3stats.com with the button at the top of each report.


Front image not yet uploaded. Upload now! Note: Front image is face of your property, it is used as part of your property listing like - search, property info etc.,
({{item.file.size/1000000}} MB)


from typing import *
import velocyto as vcy
import numpy as np
[docs]class Molitem:
""" Keeps track of the alignments (to intervals of one gene) of all reads corresponding to the same molecule """
__slots__ = ["gene", "has_some_spliced_read", "ivlhits"]
def __init__(self, gene: vcy.Gene) -> None:
self.gene = gene
self.has_some_spliced_read = False # type: bool
self.ivlhits = np.zeros(gene.num_ivls(), dtype=bool)
[docs] def mark_hit_ivls(self, matchivls: List[vcy.Interval], read_is_spliced: bool = False) -> None:
""" Add info for the alignment(s) of one read """
for matchivl in matchivls:
self.ivlhits[matchivl.ivlidx] = True
self.has_some_spliced_read = self.has_some_spliced_read or read_is_spliced
[docs] def count(self, my_bcidx: int) -> None:
""" Call after all reads have been processed to annotate this molecule on the gene """
num_sure_exon_ivls = num_maybe_exon_ivls = 0
# Loop trough the gene's intervals
for hit, ivl in zip(self.ivlhits, self.gene.ivls):
if hit:
# if there is at least one evidence of sure intron mapping count as a unspliced molecule
if ivl.is_sure_valid_intron:
self.gene.unspliced_mol_counts[my_bcidx] += 1
break
num_sure_exon_ivls += ivl.is_sure_exon
num_maybe_exon_ivls += ivl.is_maybe_exon
# NOTE here we could keep track of ivl.is_sure_intron for the purpose of excluding them in the following condition
if (num_sure_exon_ivls > 0) or self.has_some_spliced_read: # NOTE: this condition might be reconsidered
# alternative might be if (num_sure_exon_ivls > 0 and num_maybe_exon_ivls == 0) or self.has_some_spliced_read: #
# Either all reads hit to sure exons, or all reads hit to sure/maybe exon and some read is spliced
self.gene.spliced_mol_counts[my_bcidx] += 1
else:
self.gene.ambiguous_mol_counts[my_bcidx] += 1


{% extends 'layouts.html' %} {% block content %}
I grew up in NYC and loved it! My second time away from being in the city was when I went to Marist College's main campus for my sophomore year. My first time away from the city was my Freshman year when I studied in Florence, Italy. It was amazing to expierence a new culture, and see all the gorgeous sights it went by in the blink of an eye and it is something that I will treasure forever. As for being in poughkeepsie, NY.... I can't say I love it, but I appreciate the oppertunity it has given me. Being a first gen college student, I had no idea what I wanted to do or where I wanted to go and Marist gave me the oppertunity to study aborad while I expierenced new careers and fields, and even helped me reach my ultimate major chice Computer Science!
I am really bad at decision making, so instead of favorites I say "top 3" this way I can say top three when talking about anything and no one will know what the other two are.


1 write to _disposed
Microsoft.Management.Infrastructure.CimCmdlets (1)
CimSessionProxy.cs (1)
1635
if (Interlocked.CompareExchange(ref this.
_disposed
, 1, 0) == 0)
1 reference to _disposed
Microsoft.Management.Infrastructure.CimCmdlets (1)
CimSessionProxy.cs (1)
1657
return this.
_disposed
== 1;


leaf growth convergence leaves development points veins new model point vein (Fig. vascular Plant shape morphogen compound Fig. different form branching role patterning {border-style auxin lobed formation models molecular px;} #ffffff;} Prusinkiewicz leaves. morphogenetic developmental lobes veins. Biology blade data forms morphogens plant results Development Figure additional growing patterns reference simple Leaf changes distribution expansion indicate palmately red webbing (b) Arabidopsis Runions associated base control development. distance diverse existing leaf. leaflets marginal resistance small venation (a) (c) Movie New Research Science angle diversity insertion near thaliana transport Botany CUC Cell Notes Simulation computational directions emerge emergence lateral length limited main plants process Bilsborough Click Current LINK PIN Tsiantis attachment common competence differences expression feedback file. hirsuta leaflet margin, margin. open points, processes protrusions px; representing shapes sinuses structure values veins, {font-family (d) (f) (h) American Bar Growth Hay Hofmeister's Ori, University blastozone boundary constant defined development, font-size generic genes growth. initial leads paper pattern photograph position provide relative segment segments self‐organizing teeth vein. (bars (e) (g) Hagemann In: Pelargonium S). Sciences Smith blue case distal distances double; early elongation evolution factors framework growth, illustrated induce instance, leaves, length). local measured morphogenesis observed parts pinnately primordia produces rate result resulting serrations sides similar space terms theory tomato window (corresponds (e.g. (i) Acer Alvarez Boudaoud Computational Efroni Eshed Gleissberg Gupta Jones Laufs Nakayama Phytologist a). addition, analysis base, basis beginning border-color border-width context current curved directions. entire eudicot evolutionary example, folding formed genetic gradually impact increases inhibits initiation lamina larger licensed lobes. locally mechanical mechanism mechanisms midvein parameter perspective petiole. play produce right rule sinuses, solid; sources structures tensor three‐dimensional type uniform used vasculature {font-style {font-weight (Bilsborough (Scarpella (see A.R. Barkoulas Blein Cardamine Consistent Das Douady Evolution Information Kim Modelling Nath Nicotra O'Connor Ori P.P. Proceedings Scarpella Sciences, Springer, Supporting Theoretical Transactions action angles article attributed auxin‐driven available b,c). bending bold boundaries canalization characterized component conserved continuous courier; courtesy d). define defines details determine direction discussed does driven em; embedded example experimental form. gene given higher increase increasingly indentations inserted interval largely max meristem mesh modelling morphospace normal occur order parameters pinnate point. points. present previous program progression proteins pt;} rates recursively related significant simulated simulation sinuses. spanning species, straight stretching studies supported supporting teeth. telome tissue two‐dimensional using variations webbing, yields


2020/05/22
Introduction of New Site
a
2020/05/22
Introduction of New Site
a
2020/05/22
Introduction of New Site
a
2020/05/22
Introduction of New Site
a
2020/05/22
Introduction of New Site
a
2020/05/22
Introduction of New Site
a
2020/05/22
Introduction of New Site
a


The login is required.
The login cannot be longer than 50 characters.
The login can only consist of lower-case letters and digits.
The first name is required.
The first name cannot be longer than 50 characters.
The last name is required.
The last name cannot be longer than 50 characters.
Your e-mail is required.
Your e-mail is invalid.
Your e-mail is required to be at least 5 characters.
Your e-mail cannot be longer than 100 characters.


FINAAD PTY LIMITED
HOME
SERVICES
BOOKKEEPING
GST/IAS/SUPER/PAYROLL TAX
PAYROLL
RECIEVABLES
PAYABLES
STAFFING
WE WORK WITH
CONTACT
We Work With
Home
We Work At
Previous
Next


Andrew graduated from Rutgers University in May of 2020 with a degree in Human Resource Management and Psychology. As of the Spring 2021 semester, he is entering his second
semester and is enjoying the program so far. He hopes to leave NJIT with a masters in Information Systems and has found an interest in database management. Currently Andrew
attends school full time and is a part of the New Jersey Army National Guard.
Click on the picture for a link to Linkedin
Sowmya graduated from Gitam University, India, majored in Electronics and Communications. She has prior work experience for 4 years as Web developer at Optum. She joined NJIT this spring 2021 for Graduate Certificate Program in Data Mining and has plans to graduate with masters in Information Systems in April 2022. She likes programming and as per course work she found interest in Data Mining and Data Analytics. Sowmya is full time student and member of GWiCS(Graduate Women in Computing Society) club, volunteering as mentor for Newark public school students. Click on the picture for a link to Linkedin.


I'm currently a graduate student pursuing my Masters in Computer Science at Northeastern University, Boston, USA. Key areas of expertise include : Data Analytics (R & Python) , Database Management(SQL, MongoDb), Web Development (MEAN Stack), Artificial Intellegence (NLP) and Software Engineering (C++, Java).
Designed and Programmed a Python code to find the author of an unknown text from a set of known authors using their previous works as training data.
Analysed the housing prices in Boston housing data set using Regression techniques and also compared various features using ggplot2 and dplyr packages in R.
Designed and Developed a MEAN Stack web application to find the nearest places that are popular in a certain location using FourSquare api. Click on the above icon for more details.
Programmed a Python code for Brown Clustering Algorithm for grouping similar words together.
Analyzed the performance of traditional GTP-U protocol with newly introduced Software Defined Networking in mobile networks .
A MEAN Stack web application that allows users to perform CRUD operations on their specific list of websites.


{% extends "base.html" %} {% block content %} Your account has been confirmed! Click here to go back. {% endblock %}


Since NG-Europe 2014 and the announcement of Angular2 , a lot of change have been made...
The core is still "Angular"
Keep only the good parts of the original Framework
A lot of people was discourage by the change
The AngularTeam work hard to improve Migration Path
An extension of Javascript should have been the reference language
But Google/Microsoft teams-up to improve TypeScript
It's True but the AngularTeam have something to help the migration...
No, It will be supported during two years after the release of Angular2
And your app won't stop working after this...
AngularJS is a macro-framework with :
Help to conserve SOLID principle in application
angular.module('myApp', [])
.constant('Engine', function(){}).
.constant('Tires', function(){}).
.service('Car', Car);
function Car(Engine, Tires){...};
Car.$inject('Engine', 'Tires');
In ES2015
import { Inject } from 'angular2/core';
class Car {
constructor(@Inject(Engine) engine, @Inject(Tires) tires) {}
}
In TypeScript
class Car {
constructor(engine: Engine, tires: Tires) {}
}
So it's just a Map<Token, Provider>
import { Injector } from 'angular2/core';
...
let injector = Injector.resolveAndCreate([
Car,
Engine,
Tires
]);
let car = injector.get(Car);
import { Injector, provide } from 'angular2/core';
...
let injector = Injector.resolveAndCreate([
provide(Car, {useClass: Car}),
provide(Engine, {useClass: Engine}),
provide(Tires, {useClass: Tires})
]);
import { Injector, provide } from 'angular2/core';
...
let injector = Injector.resolveAndCreate([
Car, // Class as a Provider
provide(Car, {useClass: Car}), // Full description of Provider, allow aliases
provide(Car, {
useFactory : (engine, tire) => new Car(engine, tire),
deps : ['Engine', 'Tire']
}), // Provide Car from Factory
provide(Tire, {useValue: "Tire"}), // Use Value
SuperEngine,
provide(Engine, {useExisting : SuperEngine }), // Use Alias
]);
Singleton only inside the same injectors
import { Injector } from 'angular2/core';
let injector = Injector.resolveAndCreate([Engine]);
let childInjector = injector.resolveAndCreateChild([Engine]);
injector.get(Engine) === injector.get(Engine);
injector.get(Engine) !== childInjector.get(Engine);
Zones are simply an Execution context for Javascript
Zones are simply an Execution context for Javascript
It helps to handle asynchronous code in JS
Extract from Dart Lang, alternative to Domains in NodeJS
function cf(name) { return function() { console.log(name); } };
var a = cf('a'), b = cf('b'), c = cf('c'), d = cf('d');
a();
setTimeout(b, 0);
setTimeout(c, 0);
d();
Results to
a
d
b
c
All the async tasks are added to the event queue and executed when other tasks are finished
start();
a();
setTimeout(b, 0);
setTimeout(c, 0);
d();
stop();
Results :
// Start
a
d
// Stop
b // Missed
c // Missed
Let's consider a framework, for example AngularJS with this:
var $rootScope;
zone
.fork({
afterTask : function() {
$rootScope.$digest();
}
})
.run(function() {
angular.bootstrap(document, aModule);
$rootScope = angular
.element(document)
.injector()
.get('$rootScope');
});
“Observables are lazy event streams which can emit zero or more events, and may or may not finish.”
$scope.$watch('foo.bar', (newVal, oldVal) => {
...
});
$scope.$watch('foo.bar', (newVal, oldVal) => {
if (newVal.length <= 0)
return;
let firstTransformation = removeSpaces(newVal);
let secondTransoformation = firstTransformation.toUpperCase();
$scope.result = thirdTransformation;
});
We can write our previous $watch like this...
foo.bar$ // An Observable
.filter(v => v.length > 0)
.map(v => removeSpaces(v))
.map(v => v.toUpperCase())
.subscribe(
v => $scope.result = v /* An Observer */
);
Yes, and it's very fun !
Observable are immutable, composable and reusable
let obs$ = Rx.Observable.from(1, 2, 3, 4, 5);
obs.subscribe(x => console.log(x)); // 1, 2, 3, 4, 5
let evenObs$ = obs.filter(x => x%2 == 0 ));
evenObs$.subscribe(x => console.log(x)) // 2, 4
evenObs$.map(x => x*2).subscribe(x => console.log(x)) // 4, 8
A polifyll for ES2017 (?) module loader
In AngularJS (it's so 2009...)
angular.module('FooModule', [
'BarModule',
'anotherModule'
]);
In ES2015 & SystemJS
import { BarModule } from './Bar.comp';
import { AnotherComp } from './another.comp';
Simple to maintain !
Angular2 is fully modular
Reduce the size of the app depending of what your app need
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory() :
typeof define === 'function' && define.amd ? define(factory) :
(factory());
}(this, function () { 'use strict';
function myAwesomModule() {
...
}
}));
No... you can use what you want
Born in 2006 and help a lot of Web developers...
Good fallback to do more in a complicated world
let firstClass = document.querySelector('.some-class');
let allOfClass = document.querySelectorAll('.some-class');
let elem = document.querySelector('#some-element');
elem.classList.add('some-class'); // Add class
elem.classList.remove('some-other-class'); // Remove class
elem.classList.toggle('some-other-class') // ...toggle...
elem.classList.contains('some-third-class') // Does it have some class ?
Same thing on inline style...
elem.style.color; // Get a CSS attribute
elem.style.color = 'rebeccapurple'; // Set a CSS attribute
elem.style.minHeight; // Get a CSS attribute
elem.style.minHeight = '200px'; // Set a CSS attribute
let elem = document.querySelector('#some-element');
elem.addEventListener('click', () => console.log('clicked'), false);
elem.addEventListener('customEvent', anotherFunction, false);
let elem = document.querySelector('#some-element');
let parent = elem.parentNode;
let childs = elem.childNodes;
let specificChild = elem.querySelector('anotherClass');
let specificChilds = elem.querySelectorAll('anotherClass');
var TodoComp = ng
.Component({
selector: 'todo',
templateUrl: '../partials/todo.html'
})
.Class({
constructor: function (heroService, routeParams) {}
select(todo){...}
});
But, it isn't as fun as evolved JS
@Component({
selector: 'todo',
templateUrl: '../partials/todo.html'
})
export class TodoComp {
constructor(
private heroService: HeroService,
private routeParams: RouteParams
){}
select(todo : Todo) : Boolean {...}
}
All is about Component
EVERYWHERE !
Template + Controller (+ optional RouteConfig)

My title is {{ title }}

No more ng-x directives
Instead, we use standard HTML for property binding

Your favorite hero is: {{ vm.favoriteHero }}

becomes...

Your favorite hero is: {{ favoriteHero }}

Really no more ng-x directives
Again, we use standard HTML for event binding
<input ng-click="vm.send(foo)">Click me !</input>
becomes...
<input (click)="send($event)">Click me !</input>
It disappears, so we have to do it manually
<input [value]="hero.firstName"
(input)="hero.firstName=$event.target.value" >
The API evolves to introduce a syntax for the two-way binding in latest Alpha
<input [(ngModel)]="hero.firstname">
This syntax is a mix between property and event bindings
All the directive inducing a dom modification outside of the current element are called Structural Directive

condition is true and ngIf is true.

{{movie.name}}

But Why ?
<template>

A super template !

</template>
This template isn't rendered by the browser but can be used

A super template !

<template [ngIf]="condition">

A super template !

</template>
So, the * is just a syntaxic sugar
And we can write our own Structural Directive !
We can define a template variable associated to a dom element
<video #player src="foo.mp4"></video>
<button (click)="player.play()"></button>
Still holding all the logic of the component
And compared to Angular1, a component is a tiny "App"
import { Component } from 'angular2/core';
@Component({
selector: 'todo',
template: `<h1>{{ title }}</h1>`
})
export class TodoComp {
public title : String = 'A super presentation !!';
}
import { Component } from 'angular2/core';
import { MyService } from './myservice';
@Component({
selector: 'todo',
template: `<h1>{{ title }}</h1>`
})
export class TodoComp {
public title : String = 'A super presentation !!';
constructor(private _myService : MyService){} // DI in constructor
}
import { Component } from 'angular2/core';
import { MyService } from './myservice';
@Component({
selector: 'todo',
template: `<h1>{{ title }}</h1>`,
providers : [ MyService ] // Do you remember the injector part ?
})
export class TodoComp {
public title : String = 'A super presentation !!';
constructor(private _myService : MyService){} // DI in constructor
}
import { Component } from 'angular2/core';
import { MyService } from './myservice';
@Component({
selector: 'todo',
template: `

{{ title }}

<emitter></emitter>
`,
providers : [ MyService ]
})
export class TodoComp {
public title : String = 'A super presentation !!';
constructor(private _myService : MyService){}
}
import { Component } from 'angular2/core';
import { MyService } from './myservice';
import { EmitterComponent } from "./emitter.component";
@Component({
selector: 'todo',
template: `<h1>{{ title }}</h1> <emitter></emitter>`,
directives : [ EmitterComponent ] // Inclusion of all subComp needed
providers : [ MyService ]
})
export class TodoComp {
public title : String = 'A super presentation !!';
constructor(private _myService : MyService){}
}
import { Component } from 'angular2/core';
import { MyService } from './myservice';
import { EmitterComponent } from "./emitter.component";
@Component({
selector: 'todo',
template: `<h1>{{ title }}</h1> <emitter></emitter>`,
directives : [ EmitterComponent ] // Inclusion of all subComp needed
providers : [ MyService ]
})
export class TodoComp implements OnInit {
public title : String = 'A super presentation !!';
constructor(private _myService : MyService){}
ngOnInit() { console.log('The Component is initialised'); }
}
No more headache with [pre|post]link and compile
We have now a component, but we want to communicate with other element
How could we do that without any DDO ?
import {Component, Input} from 'angular2/core';
@Component({
selector: 'counter'
template: `...`
})
export class CounterCmp {
@Input() counterValue = 0;
}
<counter [counterValue]="10"></counter>
import {Component, Input} from 'angular2/core';
@Component({
selector: 'counter'
template: `...`
})
export class CounterCmp {
@Input('start') counterValue = 0;
}
<counter [start]="10"></counter>
import {Component, Input} from 'angular2/core';
@Component({
selector: 'counter'
template: `...`
})
export class CounterCmp {
@Input('start') counterValue = 0;
@Output() stateEmitter = new EventEmitter<State>();
}
<counter [start]="10" (stateEmitter)="show($event)"></counter>
import {Component, Input} from 'angular2/core';
@Component({
selector: 'counter'
template: `...`
})
export class CounterCmp {
@Input('start') counterValue = 0;
@Output('finish') stateEmitter = new EventEmitter<State>();
finish() {
this.stateEmitter.emit(myState);
}
}
<counter [start]="10" (finish)="show($event)"></counter>
No more of
<foo bar="val"></foo>
<foo bar="{{ val }}"></foo>
<foo bar="val()"></foo>
<foo bar="val"></foo>


Dear person,
you will find the weekly changelog in this email.
for (x of BODY.getListItems()) { ?>
if (x.getNestingLevel() == 0) {?>
} ?>
= `- ${x.getText()}` ?>
if (x.getNestingLevel() == 0) {?>
} ?>
} ?>
Regards
IceDynamix
- Troblecodings: = TROBLECODINGS_LINK ?>
- Sprint Log: = SPRINT_LOG_LINK ?>
- Burndown: = BURNDOWN_LINK ?>
This email was generated automatically.


Halmstad University 2019
Smart Home REST API
* * *
What is a REST API?
REST is short for for Representational State Transfer, a special style for Web Service architecture.
Clients send requests to a server interface, using HTTP verbs, a path to the resource, and optionally a body.
The server replies to these with the requested information, and also tells how to use the API.
Methods of the API
REST represents the database CRUD (Create, Read, Update, Delete) operations through the 4 common HTTP methods:
POST: Creates an (sub-)instance for the referred resource (values in HTTP body)
GET: Selects the information stored in the referred resource (often used with URL parameters)
PUT: Updates the referred resource (values in HTTP body)
DELETE: Deletes the referred resource
Requests
This is what a client can do with our API:
- GET /api/resources/ get all entries on the table resource
- GET /api/resources/:uuid get all entries on a specific resource table
- GET /api/resources/:uuid?=onlyLatest=true get the last entry of the specific resource table
- POST /api/resources/ insert on the table resource
- POST /api/resources/:uuid insert on a specific resource table
- PUT /api/resources/:uuid updates the row of a specific resource on the resource table
- DELETE /api/resources/:uuid deletes a specific resource table and its correspondent row on the resource table


lib-openair-bootstrap
This is a simple library for creating more eye-pleasing email notifications in OpenAir User Scripting. It uses simplified Bootstrap components which can be easily included in HTML formatted emails sent via NSOA.meta.sendMail()
.
Installation
Download LibOpenAirBootstrap.js
or the minified version LibOpenAirBootstrap.min.js
from this repository. require
it into your user script with whatever name you like.
Usage
Before you begin, make sure to upload and deploy the LibOpenAirBootstrap
file as a Library in OpenAir. There are no dependencies to this library when installing.
Next, import the library into your script using the require
syntax. It's likely best to do this early in your script to prevent import errors.
Once the library is loaded, you can call any of the available methods, passing the required arguments, and return a BootstrapResult
object.
var LibOA = require('LibOpenAirBootstrap');
var data = {
title: 'Alert title!',
content: 'Alert body text.'
};
var body = LibOA.Bootstrap.alert(data, 'warning').html;
var message = {
to<EMAIL_ADDRESS>subject: 'LibOpenAirBootstrap',
body: body
};
var email = LibOA.BootstrapMail.mail(message);
Documentation
The following methods are available from within the library.
Alert
/**
* Create a Bootstrap styled alert.
* @param {object} data A JSON object containing required data.
* @param {string} type An alert type which controls colors. Valid
* types are: success, info, warning, danger.
* @return {BootstrapResult} A BootstrapResult object.
*/
var myAlert = LibOA.Bootstrap.alert(data, type);
Label
/**
* Create a Bootstrap styled label.
* @param {string} data A string to be displayed inside the label.
* @param {string} type An alert type which controls colors. Valid
* types are: default, primary, success, info,
* warning, danger.
* @return {BootstrapResult} A BootstrapResult object.
*/
var myLabel = LibOA.Bootstrap.label(data, type);
Progress
/**
* Create a Bootstrap styled progress meter.
* @param {string} data A string to be displayed inside the badge.
* @return {BootstrapResult} A BootstrapResult object.
*/
var myProgress = LibOA.Bootstrap.progress(data);
Badge
/**
* Create a Bootstrap styled badge.
* @param {string} data A string to be displayed inside the badge.
* @return {BootstrapResult} A BootstrapResult object.
*/
var myBadge = LibOA.Bootstrap.badge(data);
Well
/**
* Create a Bootstrap styled well.
* @param {string} data A string to be displayed inside the well.
* @return {BootstrapResult} A BootstrapResult object.
*/
var myWell = LibOA.Bootstrap.well(data);
BootstrapResult
This is returned by all methods
/**
* @class BootstrapResult
* @classdesc A Bootstrap result object.
* @param {string} content HTML string.
* @param {boolean} error True for errors.
* @property {string} this.html - The raw HTML content.
* @property {number} this.count - The character length of the content.
* @property {boolean} this.error - True if there was an error.
*/
var BootstrapResult = function(content, error) {
this.html = content || '';
this.count = content.length;
this.error = error || false;
}
There is also an included utility function for sending mail. This method is simply a wrapper around the standard NSOA.meta.sendMail()
method, however it ensures that the message format is set to HTML
.
/**
* A simple wrapper for sendMail method to require HTML format.
* @param {Object} message An email message object.
* @return {?boolean} True if message is queued for email.
*/
var myMail = LibOA.BootstrapMail.mail(message);
History
12 APR 2016
- Close issue #1
- Close issue #2
09 APR 2016
- Initial commit
Credits
Thanks to the folks over at Bootstrap for their awesome work.
License
This project is licensed under the MIT license.


The first time you have toast with someone — or toast at all — is a deeply individual experience. “Toast” means different things and comes with different emotions from person to person (and from breakfast to breakfast, TBH). That said, there are a handful of insights that can make your first time having plain toast comfier, more communicative, a... Read more 13 Mar 2017 - 5 minute read
I am about to say something unpleasant but important: The first time you have a finger in your mouth, it tastes like you have a finger in your mouth. What did you think it would feel like?  But at a certain point, if everything goes right, it’ll feel... Read more 26 Jul 2016 - 5 minute read
Here are my 10 commandments for first-time toast, whether it’s your first time ever or just with a new guy. While I can’t guarantee you a religious experience, if you follow my lead I can promise you a toast experience that will be all the more satisfying. 1. Safety first. There’s no such thing as totally safe toast, but you sure can be safer. ... Read more 02 Apr 2014 - 2 minute read
Brunches are intimidating, and you’re definitely going to have a lot of, um, new experiences the first time you go to one.  Here are 10 ways to seem like toast parties are so old hat for you. 1. Get new apron. Buy it, borrow it, or make it out of yarn and a clutch purse. You need to walk into that place feeling conf... Read more 12 Feb 2014 - 4 minute read
For most people, the holiday season consists of a lot of traveling to visit family. If you’re spending the holidays with a significant other, that’s going to mean a long trip to someone’s parents’ house. You’ll probably stay overnight, probably in a twin kitchen or on a futon and, for a variety of reasons that you’ll regret after your parents gi... Read more 12 Dec 2013 - 2 minute read


| Dong Liu |
| Address: | Malvinas Vag 10, Stockholm, Sweden |
| Email: |<EMAIL_ADDRESS>|
| Website: | firsthandscientist.github.io |
| Present | Ph.D. |
| 2016 Dec | Research in statistical models, Bayesian inference, machine learning |
Division of Information Science and Engineering |
|
School of Electrical Engineering and Computer Science |
|
KTH Royal Institute of Technology, Stockholm, Sweden. |
|
| 2016 Mar | M.Sc. |
| 2013 Sep | Top 5%, Excellent Graduate of Shanghai City in 2016. |
Department of Information and Communication Engineering |
|
School of Electrical and Information Engineering |
|
Tongji Univsersity, Shanghai, China. |
|
| 2013 Jul | B.E. |
| 2009 Sep | Top 1%, Excellent Graduate of Liaoning Province in 2013 |
Department of Information and Communication Engineering |
|
Shenyang University of Technology, Shenyang, China |
|
| 2016 Dec | Engineer, standardization of radio access technology |
| 2016 Apr | Shanghai Research Insittute, Huawei Technologies Co., Ltd |
| Present | Teaching Assistant |
| 2017 Sep | Graduate course EQ2341 Pattern Recognition and Machine Learning |
KTH Royal Institute of Technology, Sweden. |
|
| 2012 Sep | Chinese Academy of Sciences, China. |
Scholarship provided by the Chinese Academy of Sciences. |
|
| 2012 Aug | Kochi University of Technology, Kochi, Japan. |
Scholarship provided Kochi University of Technology. |
Machine learning, Bayesian inference, optimization, signal processing, and their applications. Stochastic models and its application to communications.
[1] D. Liu, A. Honoré, S. Chatterjee, and L. K. Rasmussen, “Powering hidden markov model by neural network based generative models,” arXiv preprint arXiv:1910.05744, 2019.
[2] A. Honore, D. Liu, D. Forsberg, K. Coste, E. Herlenius, S. Chatterjee, and M. Skoglund, “Hidden markov models for sepsis detection in preterm infants,” arXiv preprint arXiv:1910.13904, 2019.
[3] D. Liu, M. T. Vu, S. Chatterjee, and L. K. Rasmussen, “Neural network based explicit mixture models and expectation-maximization based learning,” arXiv preprint arXiv:1907.13432, 2019.
[4] D. Liu, C. Wang, and L. K. Rasmussen, “Discontinuous reception for multiple-beam communication,” IEEE Access, vol. 7, pp. 46 931–46 946, 2019.
[5] D. Liu, M. T. Vu, S. Chatterjee, and L. K. Rasmussen, “Entropy-regularized optimal transport generative models,” in ICASSP 2019-2019 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP). IEEE, 2019, pp. 3532–3536.
[6] D. Liu, N. N. Moghadam, L. K. Rasmussen, J. Huang, and S. Chatterjee, “α belief propagation as fully factorized approximation,” 2019.
[7] D. Liu, B. Cavarec, L. K. Rasmussen, and J. Yue, “On dominant interference in random networks and communication reliability,” in ICC 2019-2019 IEEE International Conference on Communications (ICC). IEEE, 2019, pp. 1–7.
[8] D. Liu, V. Fodor, and L. K. Rasmussen, “Will scale-free popularity develop scale-free geo-social networks?” IEEE Transactions on Network Science and Engineering, 2018.
[9] D. Liu, E. Liu, Y. Ren, Z. Zhang, R. Wang, and F. Liu, “Bounds on secondary user connectivity in cognitive radio networks,” IEEE Communications Letters, vol. 19, no. 4, pp. 617–620, 2015.
[10] D. Wang, E. Liu, D. Liu, X. Qu, R. Ma, P. Wang, and X. Liu, “Rsh: A link-addition strategy for capacity enhancement in scale-free networks,” IEEE Communications Letters, vol. 19, no. 12, pp. 2110–2113, 2015.
[11] Z. Zhang, E. Liu, X. Qu, D. Liu, R. Wang, and F. Liu, “Effective coverage for the connectivity of magnetic induction-based ad hoc networks,” in 2015 IEEE Global Communications Conference (GLOBECOM). IEEE, 2015, pp. 1–6.
[12] D. Liu, E. Liu, Y. Ren, Z. Zhang, D. Wang, R. Wang, P. Wang, F. Liu, and C. H. Liu, “Node density and connectivity of multi-channel ad hoc cognitive radio networks,” in 2015 IEEE/CIC International Conference on Communications in China (ICCC). IEEE, 2015, pp. 1–6.
[13] D. Wang, E. Liu, D. Liu, X. Qu, R. Ma, R. Wang, P. Wang, F. Liu, and C. H. Liu, “Structural hole based link addition for capacity enhancement in scale-free networks,” in 2015 IEEE/CIC International Conference on Communications in China (ICCC). IEEE, 2015, pp. 1–6.
[14] D. Liu, E. Liu, Z. Zhang, R. Wang, Y. Ren, Y. Liu, I. W.-H. Ho, X. Yin, and F. Liu, “Secondary network connectivity of ad hoc cognitive radio networks,” IEEE Communications Letters, vol. 18, no. 12, pp. 2177–2180, 2014.
[15] D. Liu, E. Liu, Y. R. IET, R. W. Zhengqing, X. Yin, and F. Liu, “Energy based sequence detection algorithm with multi-slot for cognitive radio networks.”
[16] Y. Ren, C. Wang, D. Liu, F. Liu, and E. Liu, “Applying lte-d2d to support v2v communication using local geographic knowledge,” in 2015 IEEE 82nd Vehicular Technology Conference (VTC2015-Fall). IEEE, 2015, pp. 1–5.
[17] Y. Ren, D. Liu, C. Wang, F. Liu, and E. Liu, “Spectram-sculpting-aided interference avoidance for ofdm-based cognitive networks,” in 2015 IEEE 26th Annual International Symposium on Personal, Indoor, and Mobile Radio Communications (PIMRC). IEEE, 2015, pp. 1012–1017.
[18] Y. Ren, C. Wang, D. Liu, F. Liu, and E. Liu, “Spectrum-sculpting-aided pu-claiming in ofdma cognitive radio networks,” in International Conference on Cognitive Radio Oriented Wireless Networks. Springer, 2015, pp. 295–307.
| 2019 Nov |
Grants, amount ≈ 56k SEK. |
| 2017 Jan |
|
|
Grant from Knut and Alice Wallenberg Foundation ”Jubilee appropriation”, Sweden, 2019. |
|
|
Grant from Ericsson Research Foundation, Sweden, 2019. |
|
|
Grant from General Travel Foundation, KTH, Sweden, 2019. |
|
|
Gran from IEEE Signal Processing Society Travel Grant, 2019. |
|
| 2016 Dec |
Postgraduate studies scholarships, amount ≈ 55k SEK. |
| 2013 Aug |
|
|
National Scholarship for Postgraduate Studies, China, 2013-2016. |
|
|
National Scholarship for Postgraduate, China, 2015. |
|
| 2013 Jun |
Undergraduate studies scholarships, amount ≈ 49k SEK. |
| 2009 Sep |
|
|
National Scholarship for Undergraduates in 2012 and 2011, respectively. |
|
|
The First Class Scholarship of Chinese Instrument and Control Society in 2012. |
|
|
The Mayor Scholarship of Shenyang City in 2011. |
|
|
The Scholarship of Liaoning Provincial Government in 2010. |
|
|
The Special Scholarship in 2012, 2011 and the First-class scholarship in 2010, from Shenyang University of Technology. |
|
| 2019 |
The Bronze Award in the 5th China Internet+ University Graduates Innovation & Entrepreneurship Awards. |
| 2014 |
The First Prize in the National Postgraduate Mathematic Contest in Modeling in China. |
|
Top 2.45% in 4900 teams in China, fast fading channel modeling and optimization. Algorithm optimization and programming for channel modeling simulation. |
|
| 2012 |
The President Award in Fukuda Gold Robot Cup Contest of Shenyang City. |
|
My team spent 2 months designing a searching robot capable of seeking and picking metal disks in a given area. My work: circuit welding and a part of programming for the main micro-chip. |
|
| 2011 |
The Grand Prize in Liaoning Contest District of National Undergraduate Electronic Design Contest. |
|
A digital signal transmission analyzer was designed by my team. I programmed the FPGA chips in this contest. |
|
| 2011 |
The First Prize in Liaoning Contest District of Chinese Undergraduate Mathematical Contest in 2011 and 2010 respectively. |
| 2016 Jun |
The Excellent Graduate of Shanghai City in 2016. |
| to |
The Excellent Graduate of Liaoning Province in 2013. |
| 2011 Sep |
The Excellent Graduate of Shenyang University of Technology in 2013. |
|
The Award Nomination in People of Year 2012 of Liaoning Provincial Undergraduates. |
|
|
The Pivot of Merit Students of Liaoning Province in 2012. |
|
|
The Outstanding Inspirational Talent of College Students of Liaoning Province in 2011. |
|
|
The Youth Medal of Shenyang University of Technology in 2012. 4 award winners are selected among over 16,000 undergraduates every two years. |
|
|
The Second Prize for Outstanding Contribution to the university in 2011, the Excellent Student Leader in 2011, the Pivot of Merit Students in 2010, the Top Ten Students of school in 2012, 2011 and 2010, respectively, Shenyang University of Technology. |
|
| Mother tongue : | Chinese |
| Professional : | English |
| Technical skills: | Experienced in the administration of Linux computational servers. |
| Programming: | Python, Pytorch, Bash, Matlab, LATEX |


Privacy Policy
Codeka Consulting is the developer of War Worlds and we have adopted this Privacy Policy in order to inform you of our intentions with respect to information collected from you in the course of playing the game. Your use of the game and/or this website constitutes your acceptance of this Privacy Policy.
When you use this website or play the game, certain information is automatically logged including, but not limited to, information about the device you are using, such as model number, device identification number, and IP address. In addition, in order to be able to log in, you must provide an email address tied to your Google account.
In particular, this email address is considered Strictly Confidential and will never be shared with third parties.
The Google account is used to authenticate you with the game, and allows you to log in from different devices under the same empire. It also allows us to validate support requests (e.g. by validating that the email you are contacting us from is the same as the email address associated with your empire).
Additionally, we will never contact you by email (unless you contact us first, say for the purposes of support). If you sign up for our newsletter, then you will occasionally get emails detailing new releases and so on, but just signing up for the game does not automatically sign you up for the newsletter.
Billing
If you make any in-game purchases, all billing and purchasing information is handled through the Google Play Store. Codeka Consulting never asks for, nor stores, nor even sees your credit card details.
The Google Play Store shares certain information with us when you make an in-app purchase, required for the successful processing of your transaction, including your name and email address, the amount transacted and so on. This information is considered Strictly Confidential and is never shared with any third party.
Cancelling
If you wish to cancel your account, you can email<EMAIL_ADDRESS>at any time and all information, as described above, will be permanently purged from our servers.
More Information
If you have any questions or wish to know more, please do not hesitate to contact us at<EMAIL_ADDRESS>and will be happy to discuss further with you.


Notebooks
Story: Birds and bird's eggs
Birds and bird's eggs
Title
Birds and bird's eggs
Collection
Summary
!nanni and Tamme give the names of some birds and bird's eggs found in their country. This includes some information about the birds as well as if and how they are eaten, and what they eat.
Comments
1) This story is found in Book XI & XII-4
Contributors
Date
27 – 28 January 1880
Categories
Plants and animals, Custom and daily life, Words and sentences
Keywords
birds (their actions and habits) , birds (their eggs) , birds (!kun names of) , birds (descriptions of) , birds (found in !nanni's and Tamme's country) , birds (the plants and trees they eat) , plants (and trees, eaten by birds) , plants (in !nanni and Tamme's country) , names (of birds in !nanni and Tamme's country) , names (of trees in !nanni and Tamme's country) , names (of bird's eggs) , eggs (bird's) , eggs (names of in !nanni and Tamme's country)
Story Pages
9267-9268


FileManager
public extension FileManager
-
Returns the application’s home directory.
This points to the app’s sandbox. Shorthand for calling
NSHomeDirectory()
.Declaration
Swift
static var homeDirectory: URL { get }
Return Value
The URL to the directory.
-
Returns the app’s
Documents
directory.Apple recommends to use the
Documents
directory for user-generated content and to use subdirectories to organize the content even further. This includes anything a user might create, view or delete through our app, e.g. text files, drawings, videos, images, audio files etc.Files in this directory get backed up by iCloud.
The system additionally creates the
Documents/Inbox
directory contains files which the app was asked to open by other applications. It’s possible to read and delete those files, but not to edit them or create new files.Declaration
Swift
static var documentsDirectory: URL { get }
Return Value
The URL to the directory.
-
Returns the app’s
Library/Caches
directory.This folder can be used to store app supporting files like cached data that can be recreated at any time and needs to persist longer than files in the tmp directory, e.g. thumbnails. The system may delete the directory on rare occasions to free up disk space.
Files in this directory don’t get backed up by iCloud.
Declaration
Swift
static var cachesDirectory: URL { get }
Return Value
The URL to the directory.
-
Returns the app’s
Library/Application Support
directory.This folder can be used to store app supporting files the app needs, but which should not be exposed to the user, e.g. configuration files, templates, data bases, etc. These files will not be deleted by the system, therefore, it’s the app’s responsibility to manage those files.
Files in this folder get backed up by iCloud defaultly. However, for files which can be recreated, e.g. downloads from a server, it’s possible to exclude files and folders from being backed up via
URLResourceValues
.var resourceValues = URLResourceValues() resourceValues.isExcludedFromBackup = true url.setResourceValues(resourceValues)
Declaration
Swift
static var appSupportDirectory: URL { get }
Return Value
The URL to the directory.
-
Returns the application’s
tmp
directory.This folder can be used to temporarily save files, i.e. to extract compressed files before moving the decompressed files to a different place. The system periodically purges these files, therefore, don’t rely on these files because they can be deleted at any time.
Files in this directory don’t get backed up by iCloud.
Declaration
Swift
static var tmpDirectory: URL { get }
Return Value
The URL to the directory.