TWIN PEAKS: FIRE WALK WITH ME A film review by Randy Parker Copyright 1996 Randy Parker
RATING: * (out of ****)
(Review written in 1992)
When I arrived in Paris in June, 1992, I was surprised to find France plastered with posters TWIN PEAKS: FIRE WALK WITH ME, since the movie wasn't scheduled to open in the U.S. until late August. Happily, the film--the prequel to David Lynch's cult television series--was playing in a fancy, THX theater. Unfortunately, the theater was far more impressive than the movie, which absolutely stinks, much like a French lavatory. Worse, actually.
FIRE WALK WITH ME (directed by Lynch) will be completely incomprehensible to anyone who has not seen the TV series or read "Laura Palmer's Secret Diary." For "Twin Peaks" junkies, like me, the movie is only marginally improved. The plot is jumbled and illogical, not to mention excruciatingly sluggish. The first 30 minutes, which have almost nothing to do with the main story line, feature Chris Isaak and Kiefer Sutherland as FBI agents investigating a murder in Portland, Oregon. The movie then stops in Philadelphia for a nonsensical cameo by David Bowie and a BRIEF appearance by Kyle MacLachlan as Dale Cooper. Lynch then drops this plot strand altogether and abruptly shifts the setting to Twin Peaks, Washington--one year later.
Ah, Twin Peaks: "familiar territory," you think to yourself as Angelo Badalamenti's distinctive musical score chimes in. Wrong! The movie proves that you really can't go home again, or at least Lynch can't. Only about a quarter of the characters from the TV series appear in the movie: Leland Palmer, Bobby Briggs, James, Shelly, Leo, the log lady and a few others--mostly in meaningless cameos. The rest of the "Twin Peaks" cast is nowhere to be seen, and consequently, Lynch fails to recreate the spirit and flavor of TV's most enigmatic town. Cast members Michael Ontkean, Sherilyn Fenn, Piper Laurie, and Richard Beymer are sorely missed, not to mention Lara Flynn Boyle, who has been replaced by lackluster Moira Kelly in the crucial role of Donna.
The movie concentrates solely on Laura Palmer (Sheryl Lee) as she suffers through drug abuse, prostitution, and incest, during her miserable last seven days on Earth. The night of Laura's death, which is truly terrifying, is the film's only remotely effective sequence. We finally get to see exactly what happened to Laura after she jumped off James' motorcycle and ran into the woods at that lonely traffic light in the middle of nowhere. Her murder unfolds just as Agent Cooper reconstructed it in the TV series, which is gratifying for faithful "Twin Peaks" viewers. But it's an awfully small reward for sitting through a painfully awful movie.
--- Randy Parker<EMAIL_ADDRESS>http://www.shoestring.org
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


When a AuthorShadowRoot is added, UserAgentShadowRoot should exists as the oldest Shadow Root.
hoge
hogehoge


Predicting Entailment
Gavin Hackeling
In the first part of this presentation, I will describe a language-processing capability.
In the second part I will demonstrate one application of this capability.
Part I:
Predicting Entailment in Unstructured Text
Entailment is the relationship between sentences that holds when one sentence follows from another.
I ate food.
follows from
I ate pizza.
Carolina beat Duke.
follows from
North Carolina defeated Duke after crushing State.
A student presented a project.
does not follow from
No student presented.
I have built a system that predicts the entailment relations that exists between pairs of plain English texts.
Predicting entailment can allow applications to understand what a text means in relation to another.
Demo
change url. need to setup post route and do ajax response and unclude examples
Part II:
An Application of Entailment Prediction: Polar Question Answering
First, a note about search engine usage:
People often use search engines to find answers, not documents.
Many people use English sentences as their queries rather than keywords.
quotes and statistics here about search engine usage
Search engines, and assistants like Google Now and Siri, sometimes surface answers to a type of question called factoids.
These systems use structured data sources to answer factoid questions.
Producing such structured data is expensive and time-consuming.
Users like this feature, and have become habituated to it.
Statistics about habituation
The problem is that not all questions are factoids, and search engines do not answer many of these types of questions.
These other types include polar, or yes-or-no questions.
Some polar questions are difficult to rephrase as factoid questions.
Are cats crepuscular?
Did Ariel Sharon have a stroke?
Is malt an ingredient in beer?
Can Bitcoin transactions be tracked?
In my tests, users often attempted to rephrase polar questions as factoid questions.
When the polar question could not be rephrased, they used the polar question verbatim as their search query.
The answers to polar questions can sometimes be found in the descriptions of the top results, but no search engine directly surfaces an answer.
In the mobile, wearable future of computing, many interfaces will not be capable of supporting long pages of search results.
Users want services that answer their questions with as little work as possible.
Entailment prediction can be used to automatically answer polar questions using only unstructured text.
A system that answers polar questions takes one text, the user's question, as input.
It then uses a search engine to retrieve similar texts from the web.
The system predicts the entailment relations between these retrieved texts and the user's question. It uses these relations to predict a yes or no answer. High-scoring texts can be returned as justification.
If I ask "was Millard Fillmore the last Whig President?" the search engine might retrieve the following sentences:
Millard Fillmore was the last President who was neither a Democrat nor a Republican
Millard Fillmore was the 13th president.
Millard Fillmore was the 13th president and the final Whig president.
Millard Fillmore was the last President who was neither a Democrat nor a Republican
Millard Fillmore was the 13th president.
Millard Fillmore was the 13th president and the final Whig president.
The system predicts relations for each of these pairs, and uses the relations to predict a yes or no answer.
Automatically answering polar questions from unstructured text lets people use search engines intuitively; it solves a problem that will be exacerbated as mobile and wearable interfaces become more prevalent.
Entailment prediction systems will be used in other applications as they become more robust.


| Previous State | Current State | Next State |
|---|---|---|
| {{BCM_state.prev.name || 'N/a'}} | {{BCM_state.curr.name || 'N/a'}} | {{BCM_state.next.name || 'N/a'}} |
| Brake 1 Speed | {{BCM_Brake_1_spd.val}} |
|---|---|
| Brake 2 Speed | {{BCM_Brake_2_spd.val}} |
| Brake 3 Speed | {{BCM_Brake_3_spd.val}} |
| Brake 4 Speed | {{BCM_Brake_4_spd.val}} |
| BCM Pressure 1 | {{BCM_Pressure_1.val}} |
| BCM Pressure 2 | {{BCM_Pressure_2.val}} |


Name of the environment that your application is deployed to. Example: Dev, QA1, PERF34 etc.
Currently there is no way to check duplication, please make sure that it is unique enough to get the right result in Hygieia


--- layout: post title: Storyboards nature date: '2017-09-19T11:30:26+02:00' categories: - Storyboards picture_url: https://film-Storyboards.tumblr.com/post/165514561803/Storyboards-nature ---


Fuel pin-cell simulation¶
This notebook shows how ONIX can be used to run a coupled simulation of a simple fuel pin-cell. Since this model uses coupling with OpenMC, it is necessary to have OpenMC installed.
OpenMC input part¶
ONIX python input commands should be located just after OpenMC python commands in the same python input file. The OpenMC part of the input file is the same as the one you would use to launch an OpenMC simulation. Users should refer to OpenMC documentation for the corresponding Python API. In this example, however, the OpenMC part of the input file is included to better explain the articulation of ONIX with OpenMC.
[1]:
import openmc
import onix
---------------------------------------------------------------------------
ModuleNotFoundError Traceback (most recent call last)
<ipython-input-1-51377a570dec> in <module>
----> 1 import openmc
2 import onix
ModuleNotFoundError: No module named 'openmc'
This part of the OpenMC input commands create the materials that will fill the OpenMC cells.
Important to note: since ONIX cannot handle elements but only isotopes, users should only use the command “add_nuclide” for materials that are going to be depleted by ONIX. Other materials not depleted by ONIX can use “add_element”.
[ ]:
MOX_mat = openmc.Material()
MOX_mat.set_density('atom/b-cm', density = 0.06987922652 )
MOX_mat.add_nuclide('U234', 2.5952E-7)
MOX_mat.add_nuclide('U235', 5.4287E-5)
MOX_mat.add_nuclide('U238', 2.1387E-2)
MOX_mat.add_nuclide('Pu238', 4.6610E-5)
MOX_mat.add_nuclide('Pu239', 1.0156E-3)
MOX_mat.add_nuclide('Pu240', 4.8255E-4)
MOX_mat.add_nuclide('Pu241', 1.7491E-4)
MOX_mat.add_nuclide('Pu242', 1.3201E-4)
MOX_mat.add_nuclide('O16', 4.6586E-2)
clad_mat = openmc.Material()
clad_mat.set_density('atom/b-cm', density = 0.038858703999999994 )
clad_mat.add_element('Zr',3.8657E-2)
clad_mat.add_element('Fe',1.3345E-4)
clad_mat.add_element('Cr',6.8254E-5)
mod_mat = openmc.Material()
mod_mat.set_density('atom/b-cm', density = 0.0726512136)
mod_mat.add_element('H',4.8414E-2)
mod_mat.add_nuclide('O16',2.4213E-2)
mod_mat.add_nuclide('B10', 4.7896E-6)
mod_mat.add_nuclide('B11', 1.9424E-5)
mod_mat.add_s_alpha_beta('c_H_in_H2O')
# Instantiate a Materials collection
materials_file = openmc.Materials([MOX_mat, clad_mat, mod_mat])
materials_file.cross_sections = '/home/julien/cross-sections/mcnp_endfb70/cross_sections.xml'
# Export to "materials.xml"
materials_file.export_to_xml()
The following commands define the geometry and the cells.
Important to note: ONIX requires the user to define a root cell that is named “root cell”. This root cell will be used to fill the root universe.
[ ]:
# Create cylinders for the fuel and clad
fuel_outer_radius = openmc.ZCylinder(x0=0.0, y0=0.0, R=0.410)
clad_outer_radius = openmc.ZCylinder(x0=0.0, y0=0.0, R=0.475)
# Create boundary planes to surround the geometry
min_x = openmc.XPlane(x0=-0.65635, boundary_type='reflective')
max_x = openmc.XPlane(x0=+0.65635, boundary_type='reflective')
min_y = openmc.YPlane(y0=-0.65635, boundary_type='reflective')
max_y = openmc.YPlane(y0=+0.65635, boundary_type='reflective')
min_z = openmc.ZPlane(z0=-0.65635, boundary_type='reflective')
max_z = openmc.ZPlane(z0=+0.65635, boundary_type='reflective')
# Create a Universe to encapsulate the fuel pin
pin_cell_universe = openmc.Universe(name='MOX Fuel Pin')
# Create fuel Cell
MOX_cell = openmc.Cell(name='MOX fuel')
MOX_cell.fill = MOX_mat
MOX_cell.region = -fuel_outer_radius
MOX_cell.temperature = 900
pin_cell_universe.add_cell(MOX_cell)
# Create a clad Cell
clad_cell = openmc.Cell(name='Clad')
clad_cell.fill = clad_mat
clad_cell.region = +fuel_outer_radius & -clad_outer_radius
clad_cell.temperature = 600
pin_cell_universe.add_cell(clad_cell)
# Create a moderator Cell
mod_cell = openmc.Cell(name='Mod')
mod_cell.fill = mod_mat
mod_cell.region = +clad_outer_radius
mod_cell.temperature = 600
pin_cell_universe.add_cell(mod_cell)
# Create root Cell
root_cell = openmc.Cell(name='root cell')
root_cell.fill = pin_cell_universe
root_cell.region = +min_x & -max_x & +min_y & -max_y & +min_z & -max_z
# Create root Universe
root_universe = openmc.Universe(universe_id=0, name='root universe')
root_universe.add_cell(root_cell)
# Create Geometry and set root Universe
openmc_geometry = openmc.Geometry(root_universe)
# Export to "geometry.xml"
openmc_geometry.export_to_xml()
The following commands are for the simulations settings of OpenMC.
There are no particular requirements from ONIX here so users can input these commands as they would for a normal OpenMC simulation.
[ ]:
# OpenMC simulation parameters
batches = 100
inactive = 10
particles = 10000
# Instantiate a Settings object
settings_file = openmc.Settings()
settings_file.batches = batches
settings_file.inactive = inactive
settings_file.particles = particles
# Create an initial uniform spatial source distribution over fissionable zones
bounds = [-0.65635, -0.65635, -0.65635, 0.65635, 0.65635, 0.65635]
uniform_dist = openmc.stats.Box(bounds[:3], bounds[3:], only_fissionable=True)
settings_file.source = openmc.source.Source(space=uniform_dist)
#settings_file.temperature = {'method':'interpolation'}
# Export to "settings.xml"
settings_file.export_to_xml()
ONIX input part¶
This section describes the input commands for ONIX.
Defning a sequence¶
The first thing to define is the sequence of burnup points or time points that ONIX should follow when iterating between OpenMC simulations and depletion calculations.
We first define the macrostep vector in burnup units (MWd/kg) or time units (“s” for seconds, “m” for minutes, “d” for days, “y” for years). These points defines when OpenMC simulations update the neutron flux and reaction rates.
There is no need to define the initial point (which would be 0 in burnup or time units).
[ ]:
macrostep_vector = [0.1, 0.5, 2.5, 7.5, 15, 30, 60, 90, 120, 150, 180, 210, 240, 270, 300, 330, 360, 390, 420]
macrostep_unit = 'd'
We then define a vector for power of flux normalization. This vector indicates what is the value or the flux or power density to use for each macrostep. The user choose between flux and power density by defining the unit of the vector, “flux” or “power”.
The flux should be in units of \(cm^{-2}\cdot s^{-1}\), the power should be in units of \(kW/l\).
Important to note: the power density is the total power of the system divided by the total volume of the system, including non-nuclear elements such as moderator, cladding etc.
[ ]:
norma_vector = [108.93]*len(macrostep_vector)
norma_unit = 'power'
The last element of the sequence object that we need to define is the number of microsteps within each macrostep. Below, we indicate to ONIX that there should be 3 microsteps that divide each and every macrosteps.
[ ]:
microstep_vector = [3]*len(macrostep_vector)
We then instantiate a sequence object and fill it with the vectors we defined above.
Important to note: since ONIX enables the user to define multiple sequence objects within one input file, the user needs to associate each sequence object with a number id as below.
[ ]:
sequence1 = Sequence(1)
sequence1.set_macrostep(macrostep_vector, macrostep_unit)
sequence1.set_norma(norma_vector, norma_unit)
sequence1.microstep_vector = microstep_vector
Coupling with OpenMC¶
Once the sequence objects are defined, we can import parameters from OpenMC to construct ONIX depletion systems
We first need to instantiate a couple object. This object will operate all communication between OpenMC and ONIX.
[ ]:
couple = Couple_openmc()
ONIX will run a dummy OpenMC volume simulation. Because this “pre run” simulation calculates volumes, it is necessary to provide a bounding box to ONIX.
Important to note: ONIX can use the volume provided by this simulation for the burnup regions that the user wants to deplete. However, due to non-negligible errors in the stochastic volume calculation of OpenMC, it is recommended
[ ]:
couple.set_bounding_box([-0.65635, -0.65635, -0.65635], [0.65635, 0.65635, 0.65635])
[Optional]: simulations on HPC clusters require to explicitly define the path to the OpenMC executable in the openmc.run() command. The user should indicate the path to OpenMC executable to ONIX with the following command:
[ ]:
couple.openmc_bin_path = '/home/julien/virtualenvs/py3/bin/openmc'
The user can select which OpenMC cells will be depleted by adding the names of the cell objects defined above in the command below. Cells that are selected for depletion are called BUCells in ONIX.
[ ]:
couple.select_bucells([MOX_cell])
The following command indicate to ONIX which OpenMC cell is the root cell. ONIX will use this cell to extract information on OpenMC materials and cells.
[ ]:
couple.import_openmc(root_cell)
[Optional] By default, ONIX will use ENDF/B-VIII.0 libraries for decay and fission yields data. If users want to use other libraries, they can use the following commands:
Important to note: if users want to complement the fission yield data library they are defining with the data from ENDF/B-VIII.0, they should set the complete parameter to True in the set_user_fy_lib command.
[ ]:
couple.set_decay_lib('/home/julien/ONIX/ONIX/onix/data/other_libs/origen2.2/decay_lib')
couple.set_user_fy_lib('/home/julien/ONIX/ONIX/onix/data/other_libs/origen2.2/fy_lib', complete=True)
As explained above, OpenMC volume calculations are not always reliable, especially for complex geometry. The user can dedice to manually set volumes for each BUCell.
[ ]:
vol_dict = {'MOX fuel': 0.69323, 'total volume':2.26197}
couple.set_vol(vol_dict)
Now we can indicate to the couple object which sequence it should use for the simulation.
[ ]:
couple.set_sequence(sequence1)
We can finally ask ONIX to burn the system and launch the coupled simulation
[ ]:
couple.burn()
Output results are going to be located in two types of folder. Per step folders include densities, power, neutron flux, burnup, one-group cross sections and burnup matrices for each macrostep, separately. The output summary folder contains aggregated output results for the whole simulation and for every macrostep.


--- layout: default title: Foundation - Jekyll base_url: "../../" ---
A Bare Bones Foundation & Jekyll site starting point that doesn’t assume anything.
Current - {{ site.current_version }}
This repo was created as a starting point to use Foundation & Jekyll to create static websites. There aren’t many (if any) Foundation & Jekyll scaffolds, so I created one. This repo is geared more towards building static sites, not just a blog. Hopefully you’ll find it as useful as I do.
Clone the repo and start building your site:
git clone git@github.com:aaronkwhite/bootstrap-jekyll.git project-name
The core components are located in the source directory, so you can better organize your content and stucture.
This repo is using Foundation Sass & Font-Awesome Sass, located in the root directory. You’ll need to setup Compass or use Codekit to compile the Sass into the source/assets/stylesheets
directory.
To test your site locally just run:
jekyll serve
Note: Make sure you update your git remote before you try to push any changes.
If you would like to contribute to this repo, hit me up on twitter @aaronkwhite and then we can talk pull requests.


About Pykell
Pykell is a Python 3 module for generating static websites or goodlooking documents. Thanks to pandoc and pypandoc.
Features
- generating html from an input markdown file
- generating pdf from an input markdown file (XeLaTeX required, easyiest way to get it: install TeXLive or MiKTeX
- input files can have a yaml
- if the tex template uses the listings package, syntax highlighted code listings are possible.
- merge pdfs.
- copy directory structures and files (useful for images, css and js stuff).
- generate filelists, either for internal stuff or as a html snippet.
- including text via a variable in a template (for example a filelist html snippet)
TODO:
- implementing a server listening to the output directory
- checking files, only process if either the input or the template changed
- maybe some kind of gallery thing
Example
The following code shows how the example is build
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from Pykell import Pykell
site = Pykell(False)
def main():
for f in ['README.md',]:
site.compile(f, 'demo/', 'templates/example.tex','pdf')
site.compile(f, 'demo/', 'templates/example.html')
site.copyDir('css/','demo/')
class Site(Pykell):
if __name__ == '__main__':
main()


Based on the code published by Trevor Dixon in his answer to the Stack Overflow question "Polymer 1.0 template bind ref equivalent"
Click here to run the tests...
Click here to read the documentation...
Click here to read the changelog...
[[key]]


Apache Lucene - Index File Formats
Index File Formats
This document defines the index file formats used in Lucene version 2.1. If you are using a different version of Lucene, please consult the copy of docs/fileformats.html that was distributed with the version you are using.
Apache Lucene is written in Java, but several efforts are underway to write versions of Lucene in other programming languages. If these versions are to remain compatible with Apache Lucene, then a language-independent definition of the Lucene index format is required. This document thus attempts to provide a complete and independent definition of the Apache Lucene 2.1 file formats.
As Lucene evolves, this document should evolve. Versions of Lucene in different programming languages should endeavor to agree on file formats, and generate new versions of this document.
Compatibility notes are provided in this document, describing how file formats have changed from prior versions.
In version 2.1, the file format was changed to allow lock-less commits (ie, no more commit lock). The change is fully backwards compatible: you can open a pre-2.1 index for searching or adding/deleting of docs. When the new segments file is saved (committed), it will be written in the new file format (meaning no specific "upgrade" process is needed). But note that once a commit has occurred, pre-2.1 Lucene will not be able to read the index.
Definitions
The fundamental concepts in Lucene are index, document, field and term.
An index contains a sequence of documents.
-
A document is a sequence of fields.
-
A field is a named sequence of terms.
- A term is a string.
The same string in two different fields is considered a different term. Thus terms are represented as a pair of strings, the first naming the field, and the second naming text within the field.
Inverted Indexing
The index stores statistics about terms in order to make term-based search more efficient. Lucene's index falls into the family of indexes known as an inverted index. This is because it can list, for a term, the documents that contain it. This is the inverse of the natural relationship, in which documents list terms.
Types of Fields
In Lucene, fields may be stored, in which case their text is stored in the index literally, in a non-inverted manner. Fields that are inverted are called indexed. A field may be both stored and indexed.
The text of a field may be tokenized into terms to be indexed, or the text of a field may be used literally as a term to be indexed. Most fields are tokenized, but sometimes it is useful for certain identifier fields to be indexed literally.
See the Field java docs for more information on Fields.
Segments
Lucene indexes may be composed of multiple sub-indexes, or segments. Each segment is a fully independent index, which could be searched separately. Indexes evolve by:
-
Creating new segments for newly added documents.
-
Merging existing segments.
Searches may involve multiple segments and/or multiple indexes, each index potentially composed of a set of segments.
Document Numbers
Internally, Lucene refers to documents by an integer document number. The first document added to an index is numbered zero, and each subsequent document added gets a number one greater than the previous.
Note that a document's number may change, so caution should be taken when storing these numbers outside of Lucene. In particular, numbers may change in the following situations:
-
The numbers stored in each segment are unique only within the segment, and must be converted before they can be used in a larger context. The standard technique is to allocate each segment a range of values, based on the range of numbers used in that segment. To convert a document number from a segment to an external value, the segment's base document number is added. To convert an external value back to a segment-specific value, the segment is identified by the range that the external value is in, and the segment's base value is subtracted. For example two five document segments might be combined, so that the first segment has a base value of zero, and the second of five. Document three from the second segment would have an external value of eight.
-
When documents are deleted, gaps are created in the numbering. These are eventually removed as the index evolves through merging. Deleted documents are dropped when segments are merged. A freshly-merged segment thus has no gaps in its numbering.
Overview
Each segment index maintains the following:
-
Field names. This contains the set of field names used in the index.
-
Stored Field values. This contains, for each document, a list of attribute-value pairs, where the attributes are field names. These are used to store auxiliary information about the document, such as its title, url, or an identifier to access a database. The set of stored fields are what is returned for each hit when searching. This is keyed by document number.
-
Term dictionary. A dictionary containing all of the terms used in all of the indexed fields of all of the documents. The dictionary also contains the number of documents which contain the term, and pointers to the term's frequency and proximity data.
-
Term Frequency data. For each term in the dictionary, the numbers of all the documents that contain that term, and the frequency of the term in that document.
-
Term Proximity data. For each term in the dictionary, the positions that the term occurs in each document.
-
Normalization factors. For each field in each document, a value is stored that is multiplied into the score for hits on that field.
-
Term Vectors. For each field in each document, the term vector (sometimes called document vector) may be stored. A term vector consists of term text and term frequency. To add Term Vectors to your index see the Field constructors
-
Deleted documents. An optional file indicating which documents are deleted.
Details on each of these are provided in subsequent sections.
File Naming
All files belonging to a segment have the same name with varying extensions. The extensions correspond to the different file formats described below. When using the Compound File format (default in 1.4 and greater) these files are collapsed into a single .cfs file (see below for details)
Typically, all segments in an index are stored in a single directory, although this is not required.
As of version 2.1 (lock-less commits), file names are never re-used (there is one exception, "segments.gen", see below). That is, when any file is saved to the Directory it is given a never before used filename. This is achieved using a simple generations approach. For example, the first segments file is segments_1, then segments_2, etc. The generation is a sequential long integer represented in alpha-numeric (base 36) form.
Primitive Types
Byte
The most primitive type is an eight-bit byte. Files are accessed as sequences of bytes. All other data types are defined as sequences of bytes, so file formats are byte-order independent.
UInt32
32-bit unsigned integers are written as four bytes, high-order bytes first.
UInt32 --> <Byte>4
Uint64
64-bit unsigned integers are written as eight bytes, high-order bytes first.
UInt64 --> <Byte>8
VInt
A variable-length format for positive integers is defined where the high-order bit of each byte indicates whether more bytes remain to be read. The low-order seven bits are appended as increasingly more significant bits in the resulting integer value. Thus values from zero to 127 may be stored in a single byte, values from 128 to 16,383 may be stored in two bytes, and so on.
VInt Encoding Example
|
Value |
First byte |
Second byte |
Third byte |
|
0 |
00000000 |
|
|
|
1 |
00000001 |
|
|
|
2 |
00000010 |
|
|
|
... |
|
|
|
|
127 |
01111111 |
|
|
|
128 |
10000000 |
00000001 |
|
|
129 |
10000001 |
00000001 |
|
|
130 |
10000010 |
00000001 |
|
|
... |
|
|
|
|
16,383 |
11111111 |
01111111 |
|
|
16,384 |
10000000 |
10000000 |
00000001 |
|
16,385 |
10000001 |
10000000 |
00000001 |
|
... |
|
|
|
This provides compression while still being efficient to decode.
Chars
Lucene writes unicode character sequences using Java's "modified UTF-8 encoding" .
String
Lucene writes strings as a VInt representing the length, followed by the character data.
String --> VInt, Chars
Per-Index Files
The files in this section exist one-per-index.
Segments File
The active segments in the index are stored in the segment info file, segments_N. There may be one or more segments_N files in the index; however, the one with the largest generation is the active one (when older segments_N files are present it's because they temporarily cannot be deleted, or, a writer is in the process of committing, or a custom IndexDeletionPolicy is in use). This file lists each segment by name, has details about the separate norms and deletion files, and also contains the size of each segment.
As of 2.1, there is also a file segments.gen. This file contains the current generation (the _N in segments_N) of the index. This is used only as a fallback in case the current generation cannot be accurately determined by directory listing alone (as is the case for some NFS clients with time-based directory cache expiraation). This file simply contains an Int32 version header (SegmentInfos.FORMAT_LOCKLESS = -2), followed by the generation recorded as Int64, written twice.
Pre-2.1: Segments --> Format, Version, NameCounter, SegCount, <SegName, SegSize> SegCount
2.1 and above: Segments --> Format, Version, NameCounter, SegCount, <SegName, SegSize, DelGen, HasSingleNormFile, NumField, NormGenNumField, IsCompoundFile>SegCount
Format, NameCounter, SegCount, SegSize, NumField --> Int32
Version, DelGen, NormGen --> Int64
SegName --> String
IsCompoundFile, HasSingleNormFile --> Int8
Format is -1 as of Lucene 1.4 and -3 (SemgentInfos.FORMAT_SINGLE_NORM_FILE) as of Lucene 2.1.
Version counts how often the index has been changed by adding or deleting documents.
NameCounter is used to generate names for new segment files.
SegName is the name of the segment, and is used as the file name prefix for all of the files that compose the segment's index.
SegSize is the number of documents contained in the segment index.
DelGen is the generation count of the separate deletes file. If this is -1, there are no separate deletes. If it is 0, this is a pre-2.1 segment and you must check filesystem for the existence of _X.del. Anything above zero means there are separate deletes (_X_N.del).
NumField is the size of the array for NormGen, or -1 if there are no NormGens stored.
NormGen records the generation of the separate norms files. If NumField is -1, there are no normGens stored and they are all assumed to be 0 when the segment file was written pre-2.1 and all assumed to be -1 when the segments file is 2.1 or above. The generation then has the same meaning as delGen (above).
IsCompoundFile records whether the segment is written as a compound file or not. If this is -1, the segment is not a compound file. If it is 1, the segment is a compound file. Else it is 0, which means we check filesystem to see if _X.cfs exists.
If HasSingleNormFile is 1, then the field norms are written as a single joined file (with extension .nrm); if it is 0 then each field's norms are stored as separate .fN files. See "Normalization Factors" below for details.
Lock File
The write lock, which is stored in the index directory by default, is named "write.lock". If the lock directory is different from the index directory then the write lock will be named "XXXX-write.lock" where XXXX is a unique prefix derived from the full path to the index directory. When this file is present, a writer is currently modifying the index (adding or removing documents). This lock file ensures that only one writer is modifying the index at a time.
Note that prior to version 2.1, Lucene also used a commit lock. This was removed in 2.1.
Deletable File
Prior to Lucene 2.1 there was a file "deletable" that contained details about files that need to be deleted. As of 2.1, a writer dynamically computes the files that are deletable, instead, so no file is written.
Compound Files
Starting with Lucene 1.4 the compound file format became default. This is simply a container for all files described in the next section (except for the .del file).
Compound (.cfs) --> FileCount, <DataOffset, FileName> FileCount , FileData FileCount
FileCount --> VInt
DataOffset --> Long
FileName --> String
FileData --> raw file data
The raw file data is the data from the individual files named above.
Per-Segment Files
The remaining files are all per-segment, and are thus defined by suffix.
Fields
Field Info
Field names are stored in the field info file, with suffix .fnm.
FieldInfos (.fnm) --> FieldsCount, <FieldName, FieldBits> FieldsCount
FieldsCount --> VInt
FieldName --> String
FieldBits --> Byte
- The low-order bit is one for indexed fields, and zero for non-indexed fields.
- The second lowest-order bit is one for fields that have term vectors stored, and zero for fields without term vectors.
- If the third lowest-order bit is set (0x04), term positions are stored with the term vectors.
- If the fourth lowest-order bit is set (0x08), term offsets are stored with the term vectors.
- If the fifth lowest-order bit is set (0x10), norms are omitted for the indexed field.
- If the sixth lowest-order bit is set (0x20), payloads are stored for the indexed field.
Lucene >= 1.9:
Fields are numbered by their order in this file. Thus field zero is the first field in the file, field one the next, and so on. Note that, like document numbers, field numbers are segment relative.
Stored Fields
Stored fields are represented by two files:
-
The field index, or .fdx file.
This contains, for each document, a pointer to its field data, as follows:
FieldIndex (.fdx) --> <FieldValuesPosition> SegSize
FieldValuesPosition --> Uint64
This is used to find the location within the field data file of the fields of a particular document. Because it contains fixed-length data, this file may be easily randomly accessed. The position of document n 's field data is the Uint64 at n*8 in this file.
-
The field data, or .fdt file.
This contains the stored fields of each document, as follows:
FieldData (.fdt) --> <DocFieldData> SegSize
DocFieldData --> FieldCount, <FieldNum, Bits, Value> FieldCount
FieldCount --> VInt
FieldNum --> VInt
Lucene <= 1.4:
Bits --> Byte
Value --> String
Only the low-order bit of Bits is used. It is one for tokenized fields, and zero for non-tokenized fields.
Lucene >= 1.9:
Bits --> Byte
- low order bit is one for tokenized fields
- second bit is one for fields containing binary data
- third bit is one for fields with compression option enabled (if compression is enabled, the algorithm used is ZLIB)
Value --> String | BinaryValue (depending on Bits)
BinaryValue --> ValueSize, <Byte>^ValueSize
ValueSize --> VInt
Term Dictionary
The term dictionary is represented as two files:
-
The term infos, or tis file.
TermInfoFile (.tis)--> TIVersion, TermCount, IndexInterval, SkipInterval, MaxSkipLevels, TermInfos
TIVersion --> UInt32
TermCount --> UInt64
IndexInterval --> UInt32
SkipInterval --> UInt32
MaxSkipLevels --> UInt32
TermInfos --> <TermInfo> TermCount
TermInfo --> <Term, DocFreq, FreqDelta, ProxDelta, SkipDelta>
Term --> <PrefixLength, Suffix, FieldNum>
Suffix --> String
PrefixLength, DocFreq, FreqDelta, ProxDelta, SkipDelta
--> VIntThis file is sorted by Term. Terms are ordered first lexicographically by the term's field name, and within that lexicographically by the term's text.
TIVersion names the version of the format of this file and is -2 in Lucene 1.4.
Term text prefixes are shared. The PrefixLength is the number of initial characters from the previous term which must be pre-pended to a term's suffix in order to form the term's text. Thus, if the previous term's text was "bone" and the term is "boy", the PrefixLength is two and the suffix is "y".
FieldNumber determines the term's field, whose name is stored in the .fdt file.
DocFreq is the count of documents which contain the term.
FreqDelta determines the position of this term's TermFreqs within the .frq file. In particular, it is the difference between the position of this term's data in that file and the position of the previous term's data (or zero, for the first term in the file).
ProxDelta determines the position of this term's TermPositions within the .prx file. In particular, it is the difference between the position of this term's data in that file and the position of the previous term's data (or zero, for the first term in the file.
SkipDelta determines the position of this term's SkipData within the .frq file. In particular, it is the number of bytes after TermFreqs that the SkipData starts. In other words, it is the length of the TermFreq data. SkipDelta is only stored if DocFreq is not smaller than SkipInterval.
-
The term info index, or .tii file.
This contains every IndexInterval th entry from the .tis file, along with its location in the "tis" file. This is designed to be read entirely into memory and used to provide random access to the "tis" file.
The structure of this file is very similar to the .tis file, with the addition of one item per record, the IndexDelta.
TermInfoIndex (.tii)--> TIVersion, IndexTermCount, IndexInterval, SkipInterval, MaxSkipLevels, TermIndices
TIVersion --> UInt32
IndexTermCount --> UInt64
IndexInterval --> UInt32
SkipInterval --> UInt32
TermIndices --> <TermInfo, IndexDelta> IndexTermCount
IndexDelta --> VLong
IndexDelta determines the position of this term's TermInfo within the .tis file. In particular, it is the difference between the position of this term's entry in that file and the position of the previous term's entry.
SkipInterval is the fraction of TermDocs stored in skip tables. It is used to accelerate TermDocs.skipTo(int). Larger values result in smaller indexes, greater acceleration, but fewer accelerable cases, while smaller values result in bigger indexes, less acceleration (in case of a small value for MaxSkipLevels) and more accelerable cases.
MaxSkipLevels is the max. number of skip levels stored for each term in the .frq file. A low value results in smaller indexes but less acceleration, a larger value results in slighly larger indexes but greater acceleration. See format of .frq file for more information about skip levels.
Frequencies
The .frq file contains the lists of documents which contain each term, along with the frequency of the term in that document.
FreqFile (.frq) --> <TermFreqs, SkipData> TermCount
TermFreqs --> <TermFreq> DocFreq
TermFreq --> DocDelta, Freq?
SkipData --> <<SkipLevelLength, SkipLevel> NumSkipLevels-1, SkipLevel> <SkipDatum>
SkipLevel --> <SkipDatum> DocFreq/(SkipInterval^(Level + 1))
SkipDatum --> DocSkip,PayloadLength?,FreqSkip,ProxSkip,SkipChildLevelPointer?
DocDelta,Freq,DocSkip,PayloadLength,FreqSkip,ProxSkip --> VInt
SkipChildLevelPointer --> VLong
TermFreqs are ordered by term (the term is implicit, from the .tis file).
TermFreq entries are ordered by increasing document number.
DocDelta determines both the document number and the frequency. In particular, DocDelta/2 is the difference between this document number and the previous document number (or zero when this is the first document in a TermFreqs). When DocDelta is odd, the frequency is one. When DocDelta is even, the frequency is read as another VInt.
For example, the TermFreqs for a term which occurs once in document seven and three times in document eleven would be the following sequence of VInts:
15, 8, 3
DocSkip records the document number before every SkipInterval th document in TermFreqs. If payloads are disabled for the term's field, then DocSkip represents the difference from the previous value in the sequence. If payloads are enabled for the term's field, then DocSkip/2 represents the difference from the previous value in the sequence. If payloads are enabled and DocSkip is odd, then PayloadLength is stored indicating the length of the last payload before the SkipIntervalth document in TermPositions. FreqSkip and ProxSkip record the position of every SkipInterval th entry in FreqFile and ProxFile, respectively. File positions are relative to the start of TermFreqs and Positions, to the previous SkipDatum in the sequence.
For example, if DocFreq=35 and SkipInterval=16, then there are two SkipData entries, containing the 15 th and 31 st document numbers in TermFreqs. The first FreqSkip names the number of bytes after the beginning of TermFreqs that the 16 th SkipDatum starts, and the second the number of bytes after that that the 32 nd starts. The first ProxSkip names the number of bytes after the beginning of Positions that the 16 th SkipDatum starts, and the second the number of bytes after that that the 32 nd starts.
Lucene 2.2 introduces the notion of skip levels. Each term can have multiple skip levels.
The amount of skip levels for a term is NumSkipLevels = Min(MaxSkipLevels, floor(log(DocFreq/log(SkipInterval)))).
The number of SkipData entries for a skip level is DocFreq/(SkipInterval^(Level + 1)), whereas the lowest skip
level is Level=0.
Example: SkipInterval = 4, MaxSkipLevels = 2, DocFreq = 35. Then skip level 0 has 8 SkipData entries,
containing the 3rd, 7th, 11th, 15th, 19th, 23rd,
27th, and 31st document numbers in TermFreqs. Skip level 1 has 2 SkipData entries, containing the
15th and 31st document numbers in TermFreqs.
The SkipData entries on all upper levels > 0 contain a SkipChildLevelPointer referencing the corresponding SkipData
entry in level-1. In the example has entry 15 on level 1 a pointer to entry 15 on level 0 and entry 31 on level 1 a pointer
to entry 31 on level 0.
Positions
The .prx file contains the lists of positions that each term occurs at within documents.
ProxFile (.prx) --> <TermPositions> TermCount
TermPositions --> <Positions> DocFreq
Positions --> <PositionDelta,Payload?> Freq
Payload --> <PayloadLength?,PayloadData>
PositionDelta --> VInt
PayloadLength --> VInt
PayloadData --> bytePayloadLength
TermPositions are ordered by term (the term is implicit, from the .tis file).
Positions entries are ordered by increasing document number (the document number is implicit from the .frq file).
PositionDelta is, if payloads are disabled for the term's field, the difference between the position of the current occurrence in the document and the previous occurrence (or zero, if this is the first occurrence in this document). If payloads are enabled for the term's field, then PositionDelta/2 is the difference between the current and the previous position. If payloads are enabled and PositionDelta is odd, then PayloadLength is stored, indicating the length of the payload at the current term position.
For example, the TermPositions for a term which occurs as the fourth term in one document, and as the fifth and ninth term in a subsequent document, would be the following sequence of VInts (payloads disabled):
4, 5, 4
PayloadData is metadata associated with the current term position. If PayloadLength is stored at the current position, then it indicates the length of this Payload. If PayloadLength is not stored, then this Payload has the same length as the Payload at the previous position.
Normalization Factors
Pre-2.1: There's a norm file for each indexed field with a byte for each document. The .f[0-9]* file contains, for each document, a byte that encodes a value that is multiplied into the score for hits on that field:
Norms (.f[0-9]*) --> <Byte> SegSize
2.1 and above: There's a single .nrm file containing all norms:
AllNorms (.nrm) --> NormsHeader,<Norms> NumFieldsWithNorms
Norms --> <Byte> SegSize
NormsHeader --> 'N','R','M',Version
Version --> Byte
NormsHeader has 4 bytes, last of which is the format version for this file, currently -1.
Each byte encodes a floating point value. Bits 0-2 contain the 3-bit mantissa, and bits 3-8 contain the 5-bit exponent.
These are converted to an IEEE single float value as follows:
-
If the byte is zero, use a zero float.
-
Otherwise, set the sign bit of the float to zero;
-
add 48 to the exponent and use this as the float's exponent;
-
map the mantissa to the high-order 3 bits of the float's mantissa; and
-
set the low-order 21 bits of the float's mantissa to zero.
A separate norm file is created when the norm values of an existing segment are modified. When field N is modified, a separate norm file .sN is created, to maintain the norm values for that field.
Pre-2.1: Separate norm files are created only for compound segments.
2.1 and above: Separate norm files are created (when adequate) for both compound and non compound segments.
Term Vectors
-
The Document Index or .tvx file.
This contains, for each document, a pointer to the document data in the Document (.tvd) file.
DocumentIndex (.tvx) --> TVXVersion<DocumentPosition> NumDocs
TVXVersion --> Int
DocumentPosition --> UInt64
This is used to find the position of the Document in the .tvd file.
-
The Document or .tvd file.
This contains, for each document, the number of fields, a list of the fields with term vector info and finally a list of pointers to the field information in the .tvf (Term Vector Fields) file.
Document (.tvd) --> TVDVersion<NumFields, FieldNums, FieldPositions,> NumDocs
TVDVersion --> Int
NumFields --> VInt
FieldNums --> <FieldNumDelta> NumFields
FieldNumDelta --> VInt
FieldPositions --> <FieldPosition> NumFields
FieldPosition --> VLong
The .tvd file is used to map out the fields that have term vectors stored and where the field information is in the .tvf file.
-
The Field or .tvf file.
This file contains, for each field that has a term vector stored, a list of the terms, their frequencies and, optionally, position and offest information.
Field (.tvf) --> TVFVersion<NumTerms, Position/Offset, TermFreqs> NumFields
TVFVersion --> Int
NumTerms --> VInt
Position/Offset --> Byte
TermFreqs --> <TermText, TermFreq, Positions?, Offsets?> NumTerms
TermText --> <PrefixLength, Suffix>
PrefixLength --> VInt
Suffix --> String
TermFreq --> VInt
Positions --> <VInt>TermFreq
Offsets --> <VInt, VInt>TermFreq
Notes:
- Position/Offset byte stores whether this term vector has position or offset information stored.
- Term text prefixes are shared. The PrefixLength is the number of initial characters from the previous term which must be pre-pended to a term's suffix in order to form the term's text. Thus, if the previous term's text was "bone" and the term is "boy", the PrefixLength is two and the suffix is "y".
- Positions are stored as delta encoded VInts. This means we only store the difference of the current position from the last position
- Offsets are stored as delta encoded VInts. The first VInt is the startOffset, the second is the endOffset.
Deleted Documents
The .del file is optional, and only exists when a segment contains deletions.
Although per-segment, this file is maintained exterior to compound segment files.
Pre-2.1: Deletions (.del) --> ByteCount,BitCount,Bits
2.1 and above: Deletions (.del) --> [Format],ByteCount,BitCount, Bits | DGaps (depending on Format)
Format,ByteSize,BitCount --> Uint32
Bits --> <Byte> ByteCount
DGaps --> <DGap,NonzeroByte> NonzeroBytesCount
DGap --> VInt
NonzeroByte --> Byte
Format is Optional. -1 indicates DGaps. Non-negative value indicates Bits, and that Format is excluded.
ByteCount indicates the number of bytes in Bits. It is typically (SegSize/8)+1.
BitCount indicates the number of bits that are currently set in Bits.
Bits contains one bit for each document indexed. When the bit corresponding to a document number is set, that document is marked as deleted. Bit ordering is from least to most significant. Thus, if Bits contains two bytes, 0x00 and 0x02, then document 9 is marked as deleted.
DGaps represents sparse bit-vectors more efficiently than Bits. It is made of DGaps on indexes of nonzero bytes in Bits, and the nonzero bytes themselves. The number of nonzero bytes in Bits (NonzeroBytesCount) is not stored.
For example, if there are 8000 bits and only bits 10,12,32 are set, DGaps would be used:
(VInt) 1 , (byte) 20 , (VInt) 3 , (Byte) 1
Limitations
There are a few places where these file formats limit the maximum number of terms and documents to a 32-bit quantity, or to approximately 4 billion. This is not today a problem, but, in the long term, probably will be. These should therefore be replaced with either UInt64 values, or better yet, with VInt values which have no limit.


--- layout: post status: publish published: true title: 'NLDS Game #4 Post-Game Show - Episode 8.63' author: display_name: Corey Fineran login: Corey email<EMAIL_ADDRESS>url: '' author_login: Corey author_email<EMAIL_ADDRESS>wordpress_id: 12118 wordpress_url: http://ivyenvy.com/?p=12118 date: '2016-10-12 01:02:33 +0000' date_gmt: '2016-10-12 06:02:33 +0000' categories: - Podcast tags: [] comments: [] ---
Thanks to some 9th inning heroics in Game 4, the Cubs have won the NLDS series against the San Francisco Giants and now wait to see who they will face in the NLCS, which starts on Saturday.
This episode was recorded moments after Game 4 ended.


welcome to the Lidifu Ltd website
you can sign up here sign up
This is an example of one of oure fien products
fine product
This is a wider card with supporting text below as a natural lead-in to additional content. This card has even longer content than the first to show that equal height action.
£2.49
Buy it now!Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum


We offer a range of chemical peels from a light “lunch-time” peel to a medical-grade chemical peel, such as a TCA peel or the popular VI Peel. Chemical peels work well for both men and women and are the ideal treatment for anyone who wants to restore a more youthful, healthy glow to their skin. The depth and strength of the peel used varies based on the strength of the chemicals used and the length of time the solution is applied. The formula used by your doctor will be adjusted based on your needs and skin type. Start off with a consultation to discuss which peel is right for you.


Arbitrary signing POC
Register yubikey
{{ '{{registerError}}' }}
Register
Device is registered, Sign data now
Touch yubikey now
Device registered
Sign data
{{ '{{signError}}' }}
Submit
Touch yubikey now
Data signed by hardware token.
Data signed by server:
{{ '{{signedData}}' }}


| gelman.diag {coda} | R Documentation |
The ‘potential scale reduction factor’ is calculated for each variable in
x
, together with upper and lower confidence limits. Approximate
convergence is diagnosed when the upper limit is close to 1. For
multivariate chains, a multivariate value is calculated that bounds
above the potential scale reduction factor for any linear combination
of the (possibly transformed) variables.
The confidence limits are based on the assumption that the stationary distribution of the variable under examination is normal. Hence the ‘transform’ parameter may be used to improve the normal approximation.
gelman.diag(x, confidence = 0.95, transform=FALSE, autoburnin=TRUE, multivariate=TRUE)
x |
An |
confidence |
the coverage probability of the confidence interval for the potential scale reduction factor |
transform |
a logical flag indicating whether variables in
|
autoburnin |
a logical flag indicating whether only the second half
of the series should be used in the computation. If set to TRUE
(default) and |
multivariate |
a logical flag indicating whether the multivariate potential scale reduction factor should be calculated for multivariate chains |
An object of class gelman.diag
. This is a list with the
following elements:
psrf |
A list containing the point estimates of the potential
scale reduction factor (labelled |
mpsrf |
The point estimate of the multivariate potential scale reduction
factor. This is NULL if there is only one variable in |
The gelman.diag
class has its own print
method.
Gelman and Rubin (1992) propose a general approach to monitoring
convergence of MCMC output in which m > 1 parallel chains are run
with starting values that are overdispersed relative to the posterior
distribution. Convergence is diagnosed when the chains have ‘forgotten’
their initial values, and the output from all chains is
indistinguishable. The gelman.diag
diagnostic is applied to a
single variable from the chain. It is based a comparison of within-chain
and between-chain variances, and is similar to a classical analysis of
variance.
There are two ways to estimate the variance of the stationary distribution: the mean of the empirical variance within each chain, W, and the empirical variance from all chains combined, which can be expressed as
sigma.hat^2 = (n-1)W/n + B/n
where n is the number of iterations and B/n is the empirical between-chain variance.
If the chains have converged, then both estimates are unbiased. Otherwise the first method will underestimate the variance, since the individual chains have not had time to range all over the stationary distribution, and the second method will overestimate the variance, since the starting points were chosen to be overdispersed.
The convergence diagnostic is based on the assumption that the target distribution is normal. A Bayesian credible interval can be constructed using a t-distribution with mean
mu.hat = Sample mean of all chains combined
and variance
V.hat=sigma.hat2 + B/(mn)
and degrees of freedom estimated by the method of moments
d = 2*V.hat^2/Var(V.hat)
Use of the t-distribution accounts for the fact that the mean and variance of the posterior distribution are estimated.
The convergence diagnostic itself is
R=sqrt((d+3) V.hat /((d+1)W)
Values substantially above 1 indicate lack of convergence. If the chains have not converged, Bayesian credible intervals based on the t-distribution are too wide, and have the potential to shrink by this factor if the MCMC run is continued.
The multivariate a version of Gelman and Rubin's diagnostic was proposed by Brooks and Gelman (1998). Unlike the univariate proportional scale reduction factor, the multivariate version does not include an adjustment for the estimated number of degrees of freedom.
Gelman, A and Rubin, DB (1992) Inference from iterative simulation using multiple sequences, Statistical Science, 7, 457-511.
Brooks, SP. and Gelman, A. (1998) General methods for monitoring convergence of iterative simulations. Journal of Computational and Graphical Statistics, 7, 434-455.


Run date: 2018-12-19
Student User: banjojeebus
Project: think-java
----------------------------------------------------------
[STUDENT INIT] banjojeebus
[SETUP] Creating student dir: ./stuwork/banjojeebus
[PRE-WARN]: Expected non-empty: ./stuwork/banjojeebus/think-java-banjojeebus
[GITWORK]
[Attempting DL:https://github.com/SwettSoquelHS/think-java-banjojeebus.git]
Cloning into 'think-java-banjojeebus'...
[GITWORK DONE]
[Assignment] >Think Java: Ch2-ch4<
[DESC] HW1, Ch2-Ch4
*[BEGIN chapter2]
[EXPECTING TARGETS] ['Date', 'Time']]
[COMPILING] Date.java
[SUCCESSFUL COMPILE] Date.java
[RUNNING] Date
-->
American Format: Tuesday,August 28,2018
European format: Tuesday 28 August 2018
<--
[OUTPUT OK]
[COMPILING] Time.java
[SUCCESSFUL COMPILE] Time.java
[RUNNING] Time
-->
Seconds remaining: 39870
Percent of day passed: 53.854168
<--
[OUTPUT OK]
[SUMMARY]
['Date: PASSED - EXCELLENT!'
'Time: PASSED - EXCELLENT!']
[DONE chapter2]
*[BEGIN chapter3]
[EXPECTING TARGETS] ['Exercise3', 'Exercise4']]
[ERROR] No chapter work for:chapter3
[DONE chapter3]
*[BEGIN chapter4]
[EXPECTING TARGETS] ['Multadd']]
[COMPILING] Multadd.java
[ERROR] javac failed Multadd.java Multadd.java:10: error: ';' expected
double sqrtOfx
^
1 error
[SUMMARY]
['Multadd: COMPILE ERROR (- 0.10)']
[DONE chapter4]
[ASSIGNMENT DONE] Think Java: Ch2-ch4
[SCORE] 0.15
[Assignment] >Think Java: Ch6<
[DESC] HW2, Ch 6
*[BEGIN chapter6]
[EXPECTING TARGETS] ['Exercise4', 'Exercise5']
[SUMMARY]
['Exercise4: MISSING (- 0.50)'
'Exercise5: MISSING (- 0.50)']
[DONE chapter6]
[ASSIGNMENT DONE] Think Java: Ch6
[SCORE] 0.00
[Assignment] >Swettercise1<
[DESC] HW3: Third HW Assignment, Swettercise. Assigned with Chapter6 work
*[BEGIN chapter6]
[EXPECTING TARGETS] ['Swettercise1']
[SUMMARY]
['Swettercise1: MISSING (- 0.50)']
[DONE chapter6]
[ASSIGNMENT DONE] Swettercise1
[SCORE] 0.50
[Assignment] > Think Java: Ch7 - pt1 <
[DESC] HW7: Fourth HW Assignment, Ch7 Ex3 & 4
*[BEGIN chapter7]
[EXPECTING TARGETS] ['Exercise3', 'Exercise4']
[COMPILING] Exercise3.java
[ERROR] javac failed Exercise3.java Exercise3.java:6: error: cannot find symbol
for(i = 0; i < array.length(); i ++){
^
symbol: variable i
location: class Exercise3
Exercise3.java:6: error: cannot find symbol
for(i = 0; i < array.length(); i ++){
^
symbol: variable i
location: class Exercise3
Exercise3.java:6: error: int cannot be dereferenced
for(i = 0; i < array.length(); i ++){
^
Exercise3.java:6: error: cannot find symbol
for(i = 0; i < array.length(); i ++){
^
symbol: variable i
location: class Exercise3
4 errors
[SUMMARY]
['Exercise3: COMPILE ERROR (- 0.30)'
'Exercise4: MISSING (- 0.50)']
[DONE chapter7]
[ASSIGNMENT DONE] Think Java: Ch7 - pt1
[SCORE] 0.20
[Assignment] > Think Java: Ch7 - pt2 <
[DESC] HW7: Fith HW Assignment, Ch7 Ex5, 6, 8
*[BEGIN chapter7]
[EXPECTING TARGETS] ['Exercise5', 'Exercise6', 'Exercise8']
[SUMMARY]
['Exercise5: MISSING (- 0.50)'
'Exercise6: MISSING (- 0.50)'
'Exercise8: MISSING (- 0.50)']
[DONE chapter7]
[ASSIGNMENT DONE] Think Java: Ch7 - pt2
[SCORE] 0.00
[Assignment] > Think Java: Ch11<
[DESC] HW11: HW Assignment, Ch11 Ex3
*[BEGIN chapter11]
[EXPECTING TARGETS] ['Tile']
[SUMMARY]
['Tile: MISSING (- 0.50)']
[DONE chapter11]
[ASSIGNMENT DONE] Think Java: Ch11
[SCORE] 0.50
[Assignment] > Think Java: Ch12<
[DESC] HW12: Poker Hand Test
*[BEGIN chapter12]
[EXPECTING TARGETS] ['CheckPokerHands']
[COMPILING] CheckPokerHands.java
[ERROR] javac failed CheckPokerHands.java CheckPokerHands.java:6: error: expected
System.out.print(theDeck);
^
CheckPokerHands.java:6: error: expected
System.out.print(theDeck);
^
2 errors
[SUMMARY]
['CheckPokerHands: COMPILE ERROR (- 0.30)']
[DONE chapter12]
[ASSIGNMENT DONE] Think Java: Ch12
[SCORE] 0.70


Command Line Scripts¶
Many Python packages include command line tools. This is useful for distributing support tools which are associated with a library, or just taking advantage of the setuptools / PyPI infrastructure to distribute a command line tool that happens to use Python.
For funniest, we’ll add a funniest-joke
command line tool.
There are two mechanisms that setuptools.setup()
provides to do this: the scripts
keyword argument, and the console_scripts
entry point.
The scripts
Keyword Argument¶
The first approach is to write your script in a separate file, such as you might write a shell script.:
funniest/
funniest/
__init__.py
...
setup.py
bin/
funniest-joke
...
The funniest-joke
script just looks like this:
#!/usr/bin/env python
import funniest
print funniest.joke()
Then we can declare the script in setup()
like this:
setup(
...
scripts=['bin/funniest-joke'],
...
)
When we install the package, setuptools will copy the script to our PATH and make it available for general use.:
$ funniest-joke
This has advantage of being generalizeable to non-python scripts, as well: funniest-joke
could be a shell script, or something completely different.
The console_scripts
Entry Point¶
The second approach is called an ‘entry point’. Setuptools allows modules to register entrypoints which other packages can hook into to provide certain functionality. It also provides a few itself, including the console_scripts
entry point.
This allows Python functions (not scripts!) to be directly registered as command-line accessible tools.
In this case, we’ll add a new file and function to support the command line tool:
funniest/
funniest/
__init__.py
command_line.py
...
setup.py
...
The command_line.py
submodule exists only to service the command line tool (which is a convenient organization method):
import funniest
def main():
print funniest.joke()
You can test the “script” by running it directly, e.g.:
$ python
>>> import funniest.command_line
>>> funniest.command_line.main()
...
The main()
function can then be registered like so:
setup(
...
entry_points = {
'console_scripts': ['funniest-joke=funniest.command_line:main'],
}
...
)
Again, once the package has been installed, we can use it in the same way. Setuptools will generate a standalone script ‘shim’ which imports your module and calls the registered function.
This method has the advantage that it’s very easily testable. Instead of having to shell out to spawn the script, we can have a test case that just does something like:
from unittest import TestCase
from funniest.command_line import main
class TestConsole(TestCase):
def test_basic(self):
main()
In order to make that more useful, we’ll probably want something like a context manager which temporarily captures sys.stdout
, but that is outside the scope of this tutorial.


pyrfm.random_feature.AdditiveChi2Sampler¶
-
class
pyrfm.random_feature.
AdditiveChi2Sampler
(sample_steps=2, sample_interval=None)[source]¶ Bases:
sklearn.kernel_approximation.AdditiveChi2Sampler
A wrapper of sklearn.kernel_approximation.AdditiveChi2Sampler.
- Parameters
sample_steps (int, optional) – Gives the number of (complex) sampling points.
sample_interval (float, optional) – Sampling interval. Must be specified when sample_steps not in {1,2,3}.
References
See “Efficient additive kernels via explicit feature maps” A. Vedaldi and A. Zisserman. Pattern Analysis and Machine Intelligence, 2011.
-
fit
(X, y=None)[source]¶ Set the parameters
- Parameters
X (array-like, shape (n_samples, n_features)) – Training data, where n_samples in the number of samples and n_features is the number of features.
- Returns
self – Returns the transformer.
- Return type
object
-
fit_transform
(X, y=None, **fit_params)¶ Fit to data, then transform it.
Fits transformer to X and y with optional parameters fit_params and returns a transformed version of X.
- Parameters
X (numpy array of shape [n_samples, n_features]) – Training set.
y (numpy array of shape [n_samples]) – Target values.
- Returns
X_new – Transformed array.
- Return type
numpy array of shape [n_samples, n_features_new]
-
get_params
(deep=True)¶ Get parameters for this estimator.
- Parameters
deep (boolean, optional) – If True, will return the parameters for this estimator and contained subobjects that are estimators.
- Returns
params – Parameter names mapped to their values.
- Return type
mapping of string to any
-
set_params
(**params)¶ Set the parameters of this estimator.
The method works on simple estimators as well as on nested objects (such as pipelines). The latter have parameters of the form
<component>__<parameter>
so that it’s possible to update each component of a nested object.- Returns
- Return type
self
-
transform
(X)[source]¶ Apply approximate feature map to X.
- Parameters
X ({array-like, sparse matrix}, shape = (n_samples, n_features)) –
- Returns
X_new – Whether the return value is an array of sparse matrix depends on the type of the input X.
- Return type
{array, sparse matrix}, shape = (n_samples, n_features * (2*sample_steps + 1))


IP stands for internet protocol, IP addresses on the other hand are made from bunch of numbers assigned to devices connected in a network used to communicate through internet protocol.
These numbers allow for identification as well as locating devices for both hosts and users, similarly to house addresses IP addresses help allow information or data packets to arrive from the host to the requested user without sending it to anyone else. Internet protocol also help predict the most efficient and quick way to deliver data packets to allow for the fastest path possible. This makes an efficient and private way to surf the web.
© Wenson Gan 2016


Instructions
- 1. Click Start or Join to start a new session of CodeSharing.
- 2. Enter a UniqueId (new one if you're the founder of a session).
- 3. Start coding in the code-editor which supports over 35 languages.
- 4. Share your UniqueId with your friends/colleagues.
Happy CodeSharing!!!
<
About
Technologies Used
Panel Content


3 injured in shooting outside Utah concert
by Sommer BrokawNov. 23 (UPI) -- A shooting outside a Utah concert has injured three people.
Calls of shots fired were reported at 10:13 p.m. Friday outside The Complex, a large club in Salt Lake City, where the hip-hop group Shoreline Mafia was performing.
No arrest has been reported yet.
Salt Lake City Police Lt. Carlos Valencia said someone in a white car that drove by the club started shooting and one of the victims returned fire.
The most serious injury was a gunshot wound to the chest, Valencia said, but "all are expected to recover," according to police update.
The police update said the shooting "occurred after an argument on the street and is possibly gang related."
(0) Leave a comment
upi.com/6961556
Latest Headlines
U.S. News // 1 hour ago
Ruth Bader Ginsburg released from hospital
Nov. 24 (UPI) -- Supreme Court Justice Ruth Bader Ginsburg was released from the hospital after being admitted for chills and a fever, a representative announced Sunday.
U.S. News // 3 hours ago
Michael Bloomberg officially enters race for president as Democrat
Nov. 24 (UPI) -- Michael Bloomberg, a self-made billionaire and former New York City mayor for 12 years, officially became a candidate Sunday for U.S. president, a little more than two months before Democratic caucuses and primaries take place.
U.S. News // 4 hours ago
18-year-old suspect held in fatal shooting of Alabama sheriff
Nov. 24 (UPI) -- An 18-year-old suspect was apprehended about three hours after a sheriff in a central Alabama county was fatally shot while answering a call at a convenience store Saturday night.
U.S. News // 5 hours ago
Storms to impact travel through Thanksgiving holiday week in U.S.
Nov. 24 (UPI) -- Multiple storm systems are slated to impact the United States through the Thanksgiving holiday week, bringing major travel headaches for millions of Americans.
U.S. News // 19 hours ago
Ruth Bader Ginsburg hospitalized with chills and fever
Nov. 23 (UPI) -- Supreme Court Justice Ruth Bader Ginsburg was admitted to Johns Hopkins Hospital in Baltimore Saturday after experiencing chills and a fever, the Supreme Court has announced.
U.S. News // 19 hours ago
N.J. woman convicted in pedestrian death after texting while driving
Nov. 23 (UPI) -- A New Jersey woman was convicted of vehicular homicide and sentenced to five to 10 years in prison Friday in the death of a pedestrian prosecutors said happened because the driver was texting.
U.S. News // 20 hours ago
Amtrak hits vehicle at crossing in Florida, killing three
Nov. 23 (UPI) -- Three people were killed when an Amtrak passenger train collided with a vehicle in Jupiter, Fla., Saturday.
U.S. News // 23 hours ago
Morris Meat Packing recalls over 500,000 pounds of raw pork produced without inspection
Nov. 23 (UPI) -- Morris Meat Packing has recalled approximately 515,000 pounds of raw pork after an anonymous tip that they were producing products without inspection.
U.S. News // 23 hours ago
Four injured in explosion at Dippin' Dots factory in Kentucky
Nov. 23 (UPI) -- Four people were hurt Friday in an explosion at the Dippin' Dots production facility in Paducah, Kentucky Friday. No cause has been announced but have said there was a nitrogen leak in the building.
U.S. News // 1 day ago
State Dept. releases docs on Giuliani, Pompeo contacts on Ukraine
Nov. 23 (UPI) -- A watchdog has released nearly 100 pages of court-ordered documents showing communications between President Donald Trump's personal lawyer Rudy Giuliani and Secretary of State Mike Pompeo on Ukraine.


Text Area Limit using YUI 2.7
You have entered
of
characters.
Allow me to keep typing past the character limit threshold.


--- layout: post title: City Puzzle categories: - Programming tags: [] comments: [] ---
Update 4/19/18: This puzzle was featured on FiveThirtyEight.com's Riddler column! Check it out.
I thought of a fun puzzle while I was at a conference in Downtown LA. You and I are in a city with a grid layout. All pedestrian signals alternate which direction is allowed to walk, and last exactly the same amount of time. To simplify, we are only allowed to cross one road at each intersection and we can never jaywalk.
We're trying to meet a friend at a restaurant one block north and two blocks east. We come to an intersection. We've got a walk signal going north, and a don't walk signal going east, with a big red timer counting down. The timer says one second. What do we do? Maybe you're thinking it doesn't matter?
Foolishly, you go north. Already, your fate is sealed. At the next intersection you can only go east, so you have no choice but to wait three seconds for the light to change. The intersection after that, you need to go east again. You wait an excruciating five seconds.
I go east. I lost one second waiting for the light to chance, but I'm not worried. As I arrive at the next intersection, I smile to myself and immediately walk whichever way the light allows, east in this case. At the next intersection, I wait a modest four seconds for the light to allow me to go north. One block later, I arrive at the intersection three precious seconds before you do. I high-five our mutual friend. You miss out.
What happened here? The only signal you know about is the one you're standing at. We know that you can go north immediately, but you have to wait one second to go east so, \( \tau_{north} = 0\text{ s} \) and \( \tau_{east} = 1\text{ s} \). We don't know anything about the other lights, but we can try to figure out some average behavior.
To find the average wait time, let's plot out the system. Say each walk signal lasts a time \(T\). The x-axis on the plot below is the time you arrive at the light, marked with the moments when the signals change. The y-axis is the resulting wait time to go in each direction. If you know nothing about the state of an intersection and you want to go east, you could get lucky and arrive when the light allows you to go east. You could also arrive and have to wait \(T\) seconds. One in two chance of catching a walk signal. Average wait time of \(T/2\) if you catch a don't walk signal. Overall, the average time you expect to wait is \( \left < t \right > = \frac{T}{4} \).
We can apply this to the intersections in question. At the intersection (1,0), we must go east. We could get lucky and be able to go immediately, but we expect to wait an average of \(\frac{T}{4}\). We'll write \( \left < t_{(1,0)} \right > = \frac{T}{4} \). The situation at (0,1) is the same, \( \left < t_{(0,1)} \right > = \frac{T}{4} \). At (2,0), you have to wait the same average time as at (1,0) twice, for a total wait time of \( \left < t_{(2,0)} \right > =2 \frac{T}{4} \) from (2,0) to the finish line.
Things are different at (1,1). Here, you get to make a decision. You can immediately go to either (0,1) or (1,0), whichever the light allows. Because you get to choose, the intersection at (1,1) is free. That means a total wait time of only \( \left < t_{(1,1)} \right > = \frac{T}{4} \) from here. That's the value of having multiple options.
The problem is almost solved. At (2,1), we know our options now. We can immediately go north to (2,0), where we expect to wait \(T/2\), or we can wait one second and go to (1,1), where we expect to wait \(T/4\). In other words, \(\left < t_{north}\right > = \frac{T}{2}\) and \(\left < t_{east} \right > = \frac{T}{4} + 1\text{ s}\). As long as T is longer than 4 seconds, you should go east. In general, you should go east unless \(\tau_{east} > \frac{T}{4}\).
It's more complicated for other intersections, but I wrote some code to figure it out. If you're walking in an idealized city and you have Mathematica on your phone, feel free to use it to save time. {% highlight mathematica %} {% raw %} tS[t_]:= Piecewise[{{T-t,0<=t<=T},{0,T<=t<=2T}}]/.{T->1} tE[t_]:= Piecewise[{{0,0<=t<=T},{2T-t,T<=t<=2T}}]/.{T->1} {% endraw %} expectation[fn_]:=Integrate[fn[t]/2,{t,0,2}] expectation[0,0]:= 0 expectation[0,dy_]:= expectation[dy,0] expectation[dx_,0] :=(1/2) +expectation[dx-1,0] expectation[dx_,dy_]:=expectation[Min[tE[#]+expectation[dx-1,dy],tS[#]+expectation[dx,dy-1]]&] goEast[dx_,dy_,t_]:=(expectation[dx,dy-1] >= t + expectation[dx-1,dy]) {% endhighlight %}


Welcome, Administrator!
Insert Product
Add Delivery Executive
Show All Products
Show All Delivery Executives
Log Out


Goal
Visualization of a large network with more than 2000 nodes with increasing performance
Usage of web worker API in order to increase the performance
Comparing the performance of visualizing the graph with and without web workers
Input
The input is tsv file with nodes and edges specification
Output:
The output will be in the form of a force directed graph with the nodes and edges connecting them using different layouts.


Webpack's value as a build utility is in the dependency graph. It starts from the command line and moves to the entry point defined in the config file. It finds every single dependency and "bundles" all of these dependencies together. The final product is a single "bundle" that is ready to be executed by the browser
But what if the browser isn't executing your code?
It's easy to debug a webpack bundle in the browser. Because the browser has debugging tools.
At worst, you may need to modify a webpack config to add map files or prevent obfuscation/minification.
When Webpack bundles an entire SPA, and then turns it over to .net core's Node Services, you lose the ability to debug.
All we had for debugging was console.log()
. We could set breakpoints on the .net parts of the implementation, but not on the JavaScript!
JavaScript frameworks like React and Vue are state-based. That means they store data as a "state" and then the DOM is rendered and re-rendered based on that "state".
Our "state" was the page model that we'd retrieved from our Content API.
.net core was passing a model into the Node Services, and it was getting HTML rendered by Vue back.
Since we were getting fully-rendered HTML, we lost out on an important feature: replenishing "state" (called hydration) after page load
The advantage of getting fully-rendered HTML, though, was that XPM worked flawlessly. Because it wasn't really a SPA.


@@include('./welcome.html') @@include('./monster.html') @@include('./shop.html') @@include('./tips.html') @@include('./fridge.html') @@include('./score.html')
Your browser does not support the audio element.


{% extends "base.html" %} {% load static %} {% load has_user_annotations %} {% load user_annotation_count %} {% block content %}
{{ collection.collection_image_title }}
{% if collection.collection_image_summary %}{{ collection.collection_image_summary }}
{% endif %}{{ collection.collection_image_creator }}
{{ collection.summary|safe }}


The aim of this visualization is to understand the working of t-SNE. The code for this project could find here.
Text of the element on hover
This scatter plot is generated by parsing the text of 11314 articles from 20 different target groups in the dataset. The articles are then cleaned by lemmatizing, removing of special characters and stopwords. Then each instance is turned into features vector using Sklearn's TfidfVectorizer. Then, dimensionality reduction is applied to the feature vectors using Sklearn's t-SNE. Plotly.js has been used for producing this scatter plot.


New York City Subways
The New York City Subway is a rapid transit system owned by the City of New York and leased to the New York City Transit Authority, a subsidiary agency of the state-run Metropolitan Transportation Authority (MTA). Opened in 1904, the New York City Subway is one of the world's oldest public transit systems, one of the world's most used metro systems, and the metro system with the most stations. It offers service 24 hours per day on every day of the year.
The New York City Subway is the largest rapid transit system in the world by number of stations, with 472 stations in operation (425 if stations connected by transfers are counted as single stations). Stations are located throughout the boroughs of Manhattan, Brooklyn, Queens, and the Bronx. The Staten Island Railway is not officially considered part of the subway, as it lacks a rail link with the subway system, so passengers traveling to another borough take a ferry or bus; however, free transfers are allowed to the New York City Subway and the MTA's bus system.
The Port Authority Trans-Hudson in Manhattan and the AirTrain JFK in Queens both accept the subway's MetroCard but are not operated by the MTA and do not allow free transfers. Another mass transit service that is not operated by the MTA, the Roosevelt Island Tramway, does allow free transfers to the MTA and bus systems.


<%= title %>.
<%= userview %>
Users views on Pages |
|
Users views filter by country |
|
Views over globe |
Views based on browser |


This tutorial will show you how to set up two DTN2 daemons on two separate computers and make them talk to one another.
You'll be using server config files like the one from the first tutorial. Follow these instructions on both servers, making each refer to the other one.
route local_eid dtn://name.dtn
Name can be anything you want it to be, provided it is unique for each daemon. e.g. dtn://bob.dtn. EID stands for Endpoint identifier. These are used to identify the sender and the final destination of the bundles.
We need to modify the interfaces a little. An interface looks for bundles directed to that specific daemon. It is also used for routing bundles onwards that are not intended for that specific daemon. The interface command has the following format:
interface add name_of_interface type_of_interface local_addr = local address local_port = local port number
For example:
interface add tcp0 tcp local_port=4556
tcp0 is merely the name of the interface. It doesn't matter what you choose as it's just used to refer back to the interface later on. TCP is the type of interface being used. TCP stands for Transmission Control Protocol. It is the transport layer protocol we will be using to send our bundles on. There are other transport layer protocols we can use but for now we are going to use TCP. The local_addr is the address of the computer. It can be an IP address or a name. We won't be using the name as we will be using the default IP address on the machine. Finally the (optional) local_port is the port of the machine that the daemon will listen for incoming bundles on. The default is 4556.
Next we have to set up a link between our computers. A link allows the daemons to communicate to one another via the correct IP addresses and ports. It points the bundles in the direction of the distant computer. Go down to the link section in the conf file. Add the following:
link add link_name ip address[:port number] ONDEMAND tcp
For example:
link add link_tcp <IP_ADDRESS>:4556 ONDEMAND tcp
The link_name is what the link will be called and referenced to. It may be called anything. The ip address is the IP address of the computer running the other DTN daemon. The computer name on the network can be used, for instance if DHCP is in use and we don't know the IP address of the machine. We will stick with IP addresses for now. The (optional) port number should be the port number that the other DTN daemon will listen on.
Lastly, add a route for the end point of the daemon. This locates the daemon on the other computer. Without it the bundles will not be sent.
route add name link_name
For example:
Don't forget to add the star. The asterisk is there to make all bundles match this route, instead of being mistaken as administrative bundles to be processed on the local node.route add dtn://george.dtn/* link_tcp
./dtnsend -s name of sender -d name of destination -t type of message to be sent -p name of file being sent/message being sent
The -t argument can have three values (m, f, or d) for message, file, or date.
Use dtnsend to send to one of the daemons. In this example, we'll make bob send to george:
./dtnsend -s dtn://bob.dtn/b -d dtn://george.dtn/g -t m -p "Hello george"
Notice how I have added an extra part to the daemon's EID in the source and destination parameters of the dtnsend command. The g and b are merely there to add a path for the bundle. Without the path the receiving daemon will interpret the bundle as an administrative bundle. The bundles will still go to the daemon indicated by the EID. The name of the extra part to the EID doesn't matter. It can be whatever you want it to be. Type bundle list into bob's daemon. We should see no bundles there! Then type bundle list into george's daemon. A bundle should be waiting there to be retrieved.
To retrieve the bundle, use dtnrecv. It collects the bundles and delivers the message/file/date. The dtnrecv program will wait indefinitely for new bundles to arrive from the DTN daemon. To get out of dtnrecv hit Control-C.
dtn2/apps/dtnrecv/dtnrecv dtn://george.dtn/g
The message "Hello george" should be displayed. Success!


If you'd like to chat with us directly and meet other Glowstone users, you can
join us on Discord.
This is the easiest way to get in contact with us if you need a quick response.
This is the easiest way to get in contact with us if you need a quick response.


{include file="public/head" /} {block name="css"}{/block}
{include file="public/left" /}
{include file="public/body_head" /} {block name="main"}{/block}
{include file="public/right" /}
{include file="public/footer" /} {block name="js"} {/block}


{% extends 'base.html' %} {% block title %}Contact me {% endblock %} {% block content %}
If you have any questions or comments, please email me!


MEOr
✉ Newsletter
Steam
Itch.io
Discord
Twitter
An experimental voxel sandbox game on GPU developed by Nel.


---
layout: page
title: About Me
background: '/img/bg-about.jpg'
---
I am a Computer Science graduate from University of Toronto. During my co-op terms I worked as a front-end and full stack web developer. Most recently, I worked on a research project using Python to build a simulator of the garbage collection process in large scale cloud centers. Please, visit the Projects and Coursework tab to read more about my experience and projects.
Language Proficiency
C
Python
Java
JavaScript
SQL
Web Development Tools and Frameworks
Python and Data Visualization Tools


Tech Breakfast
|
|
|
span class = "emphasistext">SSW Tech Breakfast
A big peek at ASP .NET 2 Whidbey Applications PART B
|
|
|
ASP.NET Whidbey is the current name for the next version of ASP.NET. Adam Cogan
will give a talk on: ASP.NET Whidbey overview, working with data, caching
improvements to significantly boost the performance of the next generation of
ASP.NET applications, master pages for consistent web sites, new membership
features, and personalization.
|
Tuesday 21st December.
8:00am - 11:00am at SSW
-
Register online now
-
More Info
|
|
span class = "emphasistext">SSW Tech Breakfast
eXtreme Programming for .NET Developers - with guest presenter Dr Neil
Roodyn
|
|
Using a hands on approach, this course takes you through some advanced
programming techniques for rapid development of high quality code in Visual
Studio .NET such as defining tasks; test first coding; refactoring; spiking;
automated testing and automated builds. Let Adam and Neil take you on a
fast-paced journey that will change your coding methods forever.
An introduction to tools such as:
NUnit and
NAnt , defining tasks, refactoring, automating testing,
and automating builds.
|
Friday 28th January.
8:00am - 11:00am at SSW
Register online now
|
|
Resources
|
Lumigent Log Explorer
www.ssw.com.au/ssw/LogExplorer
|
|
|
Database FAQ's and Links
http://www.ssw.com.au/ssw/Database/
DatabaseDocsLinks.aspx
|
|
Tips
|
|
|
I
think I have orphaned records in my SQL Server database. How can I check this?
- answered by David Klein.
|
How
should I increase the robustness of my SQL Server FTP replication setup? I am
running over a slow connection which can drop off without warning -
answered by David Klein.
|
|
SSW Software Audit
|
|
Companies from across the globe have been taking advantage of SSW's Software
Audit Services. The common message that is received from clients is that
getting their software built in-house can sometimes lead to a failure to
identify design flaws and architectural insufficiencies. They need an unbiased
second opinion from a knowledgeable source that can make recommendations to
improve the quality of their software.
More on SSW software audits
|
|
|
|
|
The Cutting Edge
|
|
| Merry Christmas Developers! |
Boolean member declarations should always be prefixed with "Is" or "Should" or
should be past tense verb like "Printed" or "Enabled". This way you can tell
easily which way the Boolean is directed.
More on Rules to Better Code
|
Cheers until next time,
Adam
SSW Chief Architect and Microsoft Regional Director, Australia
Got a comment for Adam?
Email Adam
|
|
|
Sydney .NET User Group - The best place to learn
.NET for free in Sydney
|
|
|
Sydney .NET User Group 15th December 2004
|
|
To celebrate the festivities of the
next few weeks, we will model Santa's hats and drink amber liquid to get
into the Christmas spirit!
Andrew Weaver will briefly talk about DotNetNuke module development. He
will demonstrate the building of a custom module and conclude with some his
experiences with the DotNetNuke framework.
In an open forum facilitated by Andrew Coates, we will share ideas, questions,
experiences, and what you want to achieve in the New Year!
|
|
Wednesday 15th December. 6:00 pm at Microsoft, 1 Epping Road North Ryde
>See You There!! |
Sorry I can't make it
|
|
eXtreme .NET eXtreme Programming for .NET Developers
|
|
To coincide with the release of his new book (http://www.awprofessional.com/title/0321303636),
Dr. Neil will be presenting eXtreme .NET at the
January SSW Tech Breakfast.
In his book, leading .NET and XP mentor Dr. Neil Roodyn covers
planning, task definition, test-driven development, user interfaces,
refactoring, spiking, pair programming, and much more. Dr Neil offers
field-proven advice for everything from automating builds to integrating
third-party libraries. He also incorporates valuable exercises and presents a
start-to-finish case study that shows exactly how XP and Microsoft .NET
interoperate throughout an entire development project.
Using a hands on approach, this course takes you through some of
advanced programming techniques introduced in the book.  But consistent code is crucial to future
development and maintenance. Built in C#, SSW Code Auditor lets you take
control of your code and automatically review your web apps and projects -
giving you more opportunity to spend time where it really matters. More on SSW Code
Auditor.
|
Advertisement - Camtech Gateway Solutions
|
|
Camtech specialises in E-Commerce Payment Gateway solutions. Camtech provide an
electronic payment solutions directly to SME's, corporates, government
organisations, ISP's and utility companies. Camtech offer the opportunity for
Web Designers, Software Developers, ISP's and any other IT related businesses,
to resell the Camtech solution as a value-add service to clients, and in-turn
create additional revenue through the sale of E-Commerce solutions.
Email Camtech sales on<EMAIL_ADDRESS>or call 1800 882 415.
|
|


Making missions is not difficult, there are many factors that go in to creating a well balanced and fun scenario. In this tutorial we are going to go over how to build a mission that can be replayed multiple times and have a different expireence each time.
It's dangerous to go alone, take this. The idea, for this scenario I took inspiration from the Great "B" and my own version of
Air Bear. This mission envloves twenty players working as a ground and air mobile force hopping
around a map and attacking enemy objectives.
enableSaving [false, false];
Disables the ability to save a in progress Scenario in the Editor
enableSentences false;
Disables the Constant "Contact 3 O Clock 10 Meters from players
this = [] execVM "briefing.sqf";
Exectutes the Briefing .sqf (more on that later).
this = [] execVM "ammo_core.sqf";
Executes the custom Ammo Box Sqf


The Bar component removes all the space between its children
so that they bump right up against eachother.
Without the Bar class
With the Bar class
It also forces the whole block to behave as a solid block that cannot break or wrap.
To force breaks you may use a

tag.
To vertically align the buttons in a Bar simply add a valign attribute.
e.g.

or

A Button
A Button
valign=bottom
A Button
A Button
valign
not set
The font-size for the contents of a Bar is hard-coded at 11px.
To override this setting, add the following to your app's custom css file:
.MyApp .Bar > * {
font-size:22px;
}
Note: replace MyApp
with the class of your actual app.
Alternatively you can subclass Bar itself.
CSS: Create your subclass.
.Bar.MyCustomBar3 > * {
font-size:22px;
}
HTML: Add your new class to a Bar element.

…


Activation of Stat 5b in erythroid progenitors correlates with the ability of ErbB to induce sustained cell proliferation.
Abstract
Self renewal of normal erythroid progenitors is induced by the receptor tyrosine kinase c-ErbB, whereas other receptors (c-Kit/Epo-R) regulate erythroid differentiation. To address possible mechanisms that could explain this selective activity of c-ErbB, we analyzed the ability of these receptors to activate the different members of the Stat transcription factor family. Ligand activation of c-ErbB induced the tyrosine phosphorylation, DNA-binding, and reporter gene transcription of Stat 5b in erythroblasts. In contrast, ligand activation of c-Kit was unable to induce any of these effects in the same cells. Activation of the erythropoietin receptor caused specific DNA-binding of Stat 5b, but failed to induce reporter gene transcription. These biochemical findings correlate perfectly with the selective ability of c-ErbB to cause sustained self renewal in erythroid progenitors.


{% extends "layout.html" %} {% block content %}
| Name | Date | Link |
|---|---|---|
| {{ result.name }} | {{ result.date }} | {{ result.name }} |
| Module | Description | Exec. |
|---|---|---|
| Executable Finder | All exec. binaries of system | Run |
| Init System | Check Init system for start apps | Run |
| File Content | Check file content for starts | Run |
| Bash Init | Check bash initialization | Run |
| Module | Description | Exec. |
|---|---|---|
| Local Processes | List system processes | Run |
| Process Interfaces | Check interfaces of processes | Run |
| System Controls | Check status and controls of system | Run |
| File System Analysis | Analyze Files that contain management info | Run |
| Module | Description | Exec. |
|---|---|---|
| Portscanner | port analysis with nmap | Run |
| Protocoll Tests | Simple Protocoll tests like HTTP | Run |
| Module | Description | Exec. |
|---|---|---|
| Network interfaces | status of network interfaces | Run |
| File System | dynamic File System Analysis | Run |
| File Handles | Check File Handles and used Files | Run |


Sealskin is a PvP guild on the Hypixel Minecraft server. The guild mainly focuses on The Bridge on Duels and BedWars, but our players are free to play all games. The guild is currently public.


题目来源：2007年上海交通大学计算机研究生机试真题
- 题目描述：
-
Today, facing the rapid development of business, SJTU recognizes that more powerful calculator should be studied, developed and appeared in future market shortly. SJTU now invites you attending such amazing research and development work.
In most business applications, the top three useful calculation operators are Addition (+), Subtraction (-) and Multiplication (×) between two given integers. Normally, you may think it is just a piece of cake. However, since some integers for calculation in business application may be very big, such as the GDP of the whole world, the calculator becomes harder to develop.
For example, if we have two integers 20 000 000 000 000 000 and 4 000 000 000 000 000, the exact results of addition, subtraction and multiplication are:
20000000000000000 +<PHONE_NUMBER>000000 = 24 000 000 000 000 000
20000000000000000 –<PHONE_NUMBER>000000 = 16 000 000 000 000 000
20000000000000000 ×<PHONE_NUMBER>000000 = 80 000 000 000 000 000 000 000 000 000 000
Note: SJTU prefers the exact format of the results rather than the float format or scientific remark format. For instance, we need "24000000000000000" rather than 2.4×10^16.
As a programmer in SJTU, your current task is to develop a program to obtain the exact results of the addition (a + b), subtraction (a – b) and multiplication (a × b) between two given integers a and b.
- 输入：
-
Each case consists of two separate lines where the first line gives the integer a and the second gives b (|a| <10^400 and |b| < 10^400).
- 输出：
-
For each case, output three separate lines showing the exact results of addition (a + b), subtraction (a – b) and multiplication (a × b) of that case, one result per lines.
- 样例输入：
-
20000000000000000<PHONE_NUMBER>000000
- 样例输出：
-
24000000000000000<PHONE_NUMBER>0000000<PHONE_NUMBER>0000000000000000000000
java 代码如下：
import java.math.BigInteger; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner s = new Scanner(System.in); while(s.hasNextBigInteger()){ BigInteger b1= s.nextBigInteger(); BigInteger b2 = s.nextBigInteger(); System.out.println(b1.add(b2)); System.out.println(b1.subtract(b2)); System.out.println(b1.multiply(b2)); } } } /************************************************************** Problem: 1037 User: coder Language: Java Result: Accepted Time:190 ms Memory:16248 kb ****************************************************************/
感謝他們的提醒或忠告，雖然不太理解。多麼精美的藝術品。已經是麥田圈的FAN了。
总结的很全面，学习了！
题目需要求解的是最小值，而且没有考虑可能存在环
妈呀！这个Dijkstra模板好长OwQ！
题目和代码都不一样好吗！！！搞错了
remove没有实现
赞一个
能不能说一下tmp数组和solve都是干嘛的？
第15行代码，/n/n，应该改为nn
第二个是python代码啊。。
嗯 分析得很到位，确实用模板编程能让面试官对你的印象更好。在设置辅助栈的时候可以这样：push时，比较要push的elem和辅助栈的栈顶，elem<=min.top()，则min.push(elem).否则只要push（elem）就好。在pop的时候，比较stack.top()与min.top(),if(stack.top()<=min.top()),则{stack.pop();min.pop();}，否则{stack.pop();}.
顺利测试通过了，多谢


Logged in: {{user}}
View Users(Admin Only)
Logout
Basketball App
Coach Information
Coaches
Team Id
Team name
Coach
{% for coach in coaches_data %}
{{coach[0]}}
{{coach[1]}}
{{coach[2]}}
{% endfor %}


Magery benchmarks
Please note:
these are very naive tests which only exist to sanity check the concept and it's performance. Don't take them too seriously.
View source
run all
suites:
benchmarks:


halo.API module¶
-
class
halo.API.
API
[source]¶ Bases:
object
This class is a wrapper for the Rest API endpoints of www.weatherbit.io. Currently it implements fetching current weather, forecast and 1 day (limit on free plan) historic weather data.
-
get_current_weather
(query)[source]¶ Fetches and returns current weather data.
Parameters: query – search query Returns: a tuple containing city, city timezone, current weather data.
-
get_forecast_weather
(query)[source]¶ Fetches and returns the forecast weather data.
Parameters: query – search query Returns: forecast weather data.
-
get_forecast_weather_chart
(query)[source]¶ Fetches and returns the forecast weather chart data.
Parameters: query – search query Returns: charting data.
-
-
exception
halo.API.
APIError
[source]¶ Bases:
Exception
An Exception class for exceptions that occur due to external problems with the API service.
-
exception
halo.API.
NotFound
[source]¶ Bases:
halo.API.APIError
An Exception that will occur when data for a city is not found.
-
exception
halo.API.
RateLimitReached
[source]¶ Bases:
halo.API.APIError
Daily rate limit of API service has been reached and we must wait until it resets.


External JavaScript
A Paragraph.
Try it
(myFunction is stored in an external file called "myScript.js")


UCR's undergraduate student body is among the 5 most diverse of major research universities in the United States, with graduation rates above the national average for all students and African American students leading the way.
UCR is a Department of Education recognized HSI that is both a Carnegie top category research and U.S. News Tier One institution.
Campus Pride lists UCR among the nation's best for lesbian, gay, bisexual and transgender students--one of the 19 given the 5 star rating. UCR is also featured in The Advocate College Guide for LGBT students.
MEI offers diversified education and training for staff and faculty with more than 20 new seminars and workshops.