Copyright © 2003 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C liability, trademark, document use and software licensing rules apply.
MathML is an XML application for describing mathematical notation, capturing both its structure and content. As such, its scope does not extend to include units - determinate quantities adopted as standards of measure - which nevertheless, by their very nature, occur in an applied mathematical setting. This Note makes recommendations and suggestions for how units can be incorporated into MathML.
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
This document makes recommendations and suggestions for how to work with units in MathML. Please report comments and errors in this document to<EMAIL_ADDRESS>This document has been produced by the W3C Math Working Group as part of the W3C Math Activity (Activity statement). The goals of the Working Group are discussed in the Working Group Charter. A list of participants in the W3C Math Working Group is available.
Publication as a Working Group Note does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress. Patent disclosures relevant to this Note may be found on the Math Working Group's patent disclosure page.
1 Introduction
1.1 Goals
1.2 Definitions
2 Display of Units in Presentation MathML
2.1 Exceptions
3 Inclusion of Units in Content MathML
4 Identifying Units in Presentation MathML
5 Identifying Unit Symbols in Content MathML
5.1 Element Content
5.2 Encoding Attribute
5.3 Definition URL Attribute
5.3.1 Base
5.3.2 Unit Name
5.3.3 Context
5.3.4 Country Code
5.3.5 Prefix
6 Facilitating the Conversion of Units in MathML
6.1 Dimension
6.2 SI Equivalent Unit
6.3 System
6.4 Foot-Pound-Second System of Units
6.5 SI Conversion Factor
6.5.1 Examples
7 Conversions Using Semantic Information
8 Examples
9 Acknowledgements
A Bibliography
B SI and IEC Prefixes
B.1 SI Prefixes
B.2 IEC Prefixes
C Dimensions
C.1 Dimensions with SI Base or Derived Units
C.2 Dimensions with Compound SI Units
The support of units within MathML [MathML2] is of primary interest to those wishing to use MathML to encode measured data. This Note presents a recommendation for how to include units in any MathML expression. It deals with both the presentation and content representations of units.
The primary reference for this document is the IEEE/ASTM SI 10-1997 Standard for the Use of the International System of Units (SI): The Modern Metric System[ieee-astm], hereafter referred to as the standard. This Note only interprets what is defined in the standard and should not be used as a replacement.
The goals of this Note are to provide suggestions and recommendations for encoding the presentation, identification, and inclusion of units in both Presentation and Content MathML.
The term unit name refers to the actual name of a unit (for example, meter, feet, torr), while unit symbol refers to usually a smaller number of characters used to represent the associated unit (for example, m, ft, Torr). Unit symbols are not abbreviations, and abbreviations should never be used as symbols. For example, use A and not amp. For archaic units with no defined symbol, use the unit name as the unit symbol.
A compound unit is a unit which is written as a product of powers of unit symbols and constants.
Section 3.5 of the standard is devoted to the style and usage of writing unit names and symbols. The following highlights the most relevant points brought up in this section and suggests possible interpretations in MathML.
When writing compound unit names, the standard recommends that they be written in full English with standard pluralization and spacing, for example, kilograms per cubic meter and meters per second squared. MathML is concerned with the incorporation of units into mathematical expressions, and so the unit names are often inappropriate. It is recommended instead that the unit symbols are used at all times.
Unit symbols are written in roman (upright) type, are not altered in the plural,
are not followed by a period except at the end of a sentence, and no space
is left between a prefix
and a unit symbol. This is accomplished in MathML by using the
mi
element. Single character symbols must be qualified by setting the
mathvariant
attribute to normal
as otherwise they would be italicized.
For example,
<mi mathvariant='normal'>m</mi>
The standard recommends that a raised dot is used to
indicate the product of two units. In Presentation MathML, this may be done through
the use of the mathematical operator <mo>·</mo>
.
For example, the newton meter may be expressed as
<mrow> <mi mathvariant='normal' class='MathML-Unit'>N</mi> <mo>·</mo> <mi mathvariant='normal' class='MathML-Unit'>m</mi> </mrow>
A quotient of two or more units may be expressed in one of the following ways:
| MathML Source | Display | Description |
|---|---|---|
<mi mathvariant='normal' class='MathML-Unit'>J</mi> <mo>/</mo> <mi mathvariant='normal' class='MathML-Unit'>kg</mi> | J/kg | |
<mi mathvariant='normal' class='MathML-Unit'>J</mi> <mo>·</mo> <msup><mi mathvariant='normal' class='MathML-Unit'>kg</mi> <mn>-1</mn></msup><mfrac> | J·kg-1 | |
<mfrac><mi mathvariant='normal' class='MathML-Unit'>J</mi> <mi mathvariant='normal' class='MathML-Unit'>kg</mi></mfrac> | the ratio of J over kg |
In representing a quotient, do not use more than one solidus (/) in the same expression unless parentheses are inserted to avoid ambiguity.
In expressing a quantity containing a value and a unit symbol, a space shall be left
between them. In MathML this is achieved by using the mathematical operator
<mo rspace="thickmathspace"></mo>
. If the
default spacing used for
is not acceptable (it is
often zero), extra space is added in MathML with the
rspace
attribute. For example, 35 mm
may be expressed as
<mrow> <mn>35</mn> <mo rspace='thickmathspace'></mo> <mi mathvariant='normal' class='MathML-Unit'>mm</mi> </mrow>
In expressing a quantity containing a value and a compound unit, the unit should remain distinct from the value. For example, in expressing 10 kg·m/s, one would use:
<mrow> <mn>10</mn> <mo rspace='thickmathspace'></mo> <mfrac> <mrow> <mi mathvariant='normal' class='MathML-Unit'>kg</mi> <mo>·</mo> <mi mathvariant='normal' class='MathML-Unit'>m</mi> </mrow> <mi mathvariant='normal' class='MathML-Unit'>s</mi> </mfrac> </mrow>
and not
<mfrac> <mrow> <mn>10</mn> <mo rspace='thickmathspace'></mo> <mi>kg</mi> <mo>·</mo> <mi mathvariant='normal'>m</mi> </mrow> <mi mathvariant='normal'>s</mi> </mfrac>
For both unit symbols and compound units, the unit should be the last term in the product.
As MathML may be used in the display of intermediate steps of a calculation, not all of the above rules may apply. For example, in finding the speed of a body which moved thirty meters in five seconds, the Presentation MathML markup may be:
<mrow> <mfrac> <mrow> <mn>30</mn> <mo rspace='thickmathspace'></mo> <mi mathvariant='normal' class='MathML-Unit'>m</mi> </mrow> <mrow> <mn>5</mn> <mo rspace='thickmathspace'></mo> <mi mathvariant='normal' class='MathML-Unit'>s</mi> </mrow> </mfrac> <mo>=</mo> <mn>6</mn> <mo rspace='thickmathspace'></mo> <mfrac> <mi mathvariant='normal' class='MathML-Unit'>m</mi> <mi mathvariant='normal' class='MathML-Unit'>s</mi> </mfrac> </mrow>
which displays as
Certain non-SI units have, through common usage, symbols which differ in the
plural. For example, the pound may be represented by the symbol
lb
or
lbs
, depending on the amount being measured. Similarly, 3.2 yards is often
written 3.2 yds.
The symbol kWh for the kilowatthour instead of kW·h is also acceptable.
Exceptions to the requirement that a space separate the quantity and unit are
the symbols for degree, minute, and second of plane angle. In this case, it would be
appropriate to use the
mo
operator. For example,
<mn>32</mn> <mo></mo> <mi mathvariant='normal' class='MathML-Unit'>°</mi> <mn>18</mn> <mo></mo> <mi mathvariant='normal' class='MathML-Unit'>'</mi> <mn>54</mn> <mo></mo> <mi mathvariant='normal' class='MathML-Unit'>"</mi>
In expressing a quantity with units,
as with Presentation MathML, it is recommended that the unit be the last child of an
apply
element which has a
times
element as the first child. It is also preferable if compound units are kept
separate as a nested apply at the end of a product.
The presentation element
mi
does not take any attributes which may be used to indicate that it represents a unit. Content
MathML must be used to identify individual or compound units.
MathML 2.0 introduced externally
defined symbols with the
csymbol
element. This element allows the author to use identifiers with externally defined semantics.
The attribute
definitionURL
is a pointer to the external definition of the semantics of the symbol. The attribute
encoding
gives the syntax of the definition pointed to by the definition URL. Thus, the
csymbol
content element as such is the appropriate tool for identifying a symbol as being a unit.
The
csymbol
element should not be used to encapsulate a compound unit. For example, the following unit
of speed should not be constructed using a single csymbol
element:
<csymbol>centimeters per second</csymbol>
or
<csymbol>cm/s</csymbol>
.
Such compound units should be represented by explicit products or quotients of simple units.
The content of the csymbol
element may consist of any
encoding which is desired to represent the unit and is not restricted in any way beyond
those already set in the MathML 2.0
specification.
The symbol g0 or gn is often used to represent the unit of acceleration due to freefall. The semantics are already defined by the attributes, and thus the content may be used to indicate the display of this unit. For example,
<csymbol definitionURL='http://.../units/gravity'><msub><mi>g</mi><mi>n</mi></msub></csymbol>
The encoding
attribute is optional and is used to help parse the actual defintion.
It is only needed if the intention is to actually interpret the definitions by machine.
The
definitionURL
attribute may be used to uniquely identify a unit. The following is a recommendation for
a unique definition URL.
The definition URL is made up of two to five parts:
http://base/units/unit name[/context][/country][#prefix]
where the context, country, and prefix are optional. The use of these parts is described below:
To this point, no fixed URL has been chosen to represent the
base of these definition URLs, so for the remainder of this Note, the base will be
indicated by ellipsis:
...
. For example,
<csymbol definitionURL='http://.../units/meter'>m</csymbol>
The unit name is spelled in full without any prefix. With
the myriad of spellings available for each unit name, even within SI, it is recommended
that the American English spelling with
standard translations to lower case ASCII characters be used wherever possible. For
example, the German Fuß and the Ångström should use the definition URLs
http://.../units/foot/de
and
http://.../units/angstrom
, respectively.
In cases where the (nonstandard) unit symbol is an abbreviation of a compound unit name, the
unit symbol should be used in place of the unit name. For example,
gallons per minute
and
revolutions per minute
should use the definition URLs should use the definition URLs
http://.../units/gpm
and
http://.../units/rpm
, respectively.
The unit name was chosen over the unit symbol for the definition URL as the name is less likely to conflict with other unit names, and unit names tend to be more easily converted to ASCII. For example, the symbol for the ohm is Ω (Ω).
The context is used only where the name is insufficient to
properly qualify the unit either through common usage or an international or scientific
agreement. No SI base units, derived units
with special names and symbols, or derived units with special names admitted for reasons of
safeguarding human health requires a context as they are understood to be the default. Of
the units in use with and in temporary use with SI, the only which require a context are
the angular minute and second, http://.../units/minute/angular
and
http://.../units/second/angular
, respectively.
An example of where a context is necessary is the U.S. survey mile. The default
international mile has the definition URL
http://.../units/mile
whereas the U.S. survey mile would use the definition URL
http://.../units/mile/survey/us
. In this case, the context is necessary as the standard U.S. mile is equal to the international
mile.
Over the years, the definitions of the various SI units have been modified. In most
cases, the definitions have been made more exact, so previous measurements are
still valid up to the
precision of the former definition. The one exception to this is the definition of the
liter. In 1901, the liter was defined as the unit of volume occupied by a mass of one
kilogram of pure water at its maximum density and at standard atmospheric pressure.
The definition of the liter was changed in 1964 to be a special name for the cubic
decimeter. These two definitions differ by approximately 28 parts per million, and thus
it is necessary to
differentiate between these two units. The context of the original liter could be the year the
definition was made, so the definition URL would be http://.../units/liter/1901
.
A date may be used in other cases where a definition has changed, where the date refers to the year the definition in question was made.
In some cases, a unit
may have multiple definitions which may be differentiated by the dimension. In this
case, the dimension could be used as the context. For example, the langley may either
be defined as
(surface energy density) or
(surface power density). The definition URLs for these two units may be
http://.../units/langley/surface_energy_density
and
http://.../units/langley/surface_power_density
, respectively.
By default, the country is referred to by the ISO 3166 country codes. In the case of historical units, where possible, the modern successor of that country should be used. Where this is not possible, ISO 3166-2 Regional codes may be used, again, if possible.
For example, the definition URL of the Scottish mile would be
http://.../units/mile/gb-sct
.
This breaks down when referring to ancient units. It would be nonsensical to refer to the Roman mile as an Italian mile. In these cases, the adjective form of the civilization is used. Some examples are given below:
arabic
athenian
egyptian
greek
hebrew
ionian
persian
prussian
rabbinical
roman
talmudic
SI accomodates decimal multiples and submultiples of units
to be represented by placing prefixes in front of the symbols. The IEC introduced
prefixes to represent binary multiples of units. A unit with a prefix is represented by
appending the prefix to the
definition URL using the fragment identifier #
. For the prefix μ
(micro)
use the recommended ASCII equivalent,
u
.
Examples:
| Unit Name | Symbol | Recommended Definition URL |
|---|---|---|
| centimeter | cm | http://.../units/meter#c |
| micrometer | μm | http://.../units/meter#u |
| kilogram | kg | http://.../units/gram#k |
| kibibyte (1024 bytes) | KiB | http://.../units/byte#Ki |
A full list of prefixes are given in B.2 IEC Prefixes. Unlike other parts of the definition URL, the prefixes should be capitalized where necessary.
A unit is a standard of measurement. In order to convert, for example, 1.35 dynes to newtons, two pieces of information are necessary:
The dimension of the unit, and
Either:
The associated system of units, or
The conversion to a known system of units.
At this point, the measurement can be converted to any other unit of equal dimension.
Suppose we wish to convert 15.3 kilometers per hour to feet per second. Both are measurements of speed, the second being the unit of speed in the foot-pound-second system of units. If we know that the conversion of km/h to SI is approximately 0.277778 m/s, then the conversion from m/s is the conversion of m to ft over the conversion of s to s, that is, 3.28084. Thus, the conversion is 15.3×0.277778×3.28084 ft/s = 13.9436 ft/s.
Suppose we want to convert 3.532 calorie hours to erg seconds. This problem may be reduced to converting the first unit to a common system of units, say SI, and then converting the corresponding SI unit to cgs system of units.
Given that cal·h and erg·s are units of action (the dimension), if we know that the conversion of 1 cal·s to SI is 15062.4 kg·m2/s. The conversion from SI to cgs is a multiplication by 107. Thus 3.532 cal·h = 3.532×15062.4×107erg·s = 5.32e11 erg·s.
Again, consider converting 83.7 statvolts per centimeter to volts per meter. This problem may be reduced to converting a unit in the electrostatic system of units (emu) to SI.
Given that sV/cm is a unit of electric field strength, we may take the product of the conversions of corresponding units of mass, length time, and electric current to get the conversion to SI. This product is 10-3×10-2/(13×2997924580-1) = 29979.2458, and therefore the conversion to SI of 87.3 statV/cm is 29979.2458 V/m.
It is always possible to determine all of this information by interpreting the MathML appropriately, although by transmitting plain MathML the task may be quite difficult. Even a unit as simple as cm/s may be stored in any of three ways:
<apply> <divide/> <csymbol definitionURL='http://.../units/meter#c>cm</csymbol> <csymbol definitionURL='http://.../units/second>s</csymbol> </apply> <apply> <times/> <csymbol definitionURL='http://.../units/meter#c>cm</csymbol> <apply> <power/> <csymbol definitionURL='http://.../units/second>s</csymbol> <cn type='integer'>-1</cn> </apply> </apply> <csymbol definitionURL='http://.../units/kyne'>kyn</csymbol>
In general, it is quite difficult to pick a unit from an expression. This section
describes a method for facilitating the transmission of unit information by making use of the
semantics
element.
Each semantics
element would contain the attribute
definitionURL="http://.../units/"
. The first
child element would be the unit encoded in either Content or Presentation MathML.
The remaining annotations may be used to facilitate interpretation and conversion of the given unit.
dimension
SI-equivalent-unit
system
SI-conversion-factor
A dimension is something which may be measured. Within the scientific community, most objects may be measured in units of length, mass, time, electric current, thermodynamic temperature, amount of substance, or luminous intensity (base dimensions) or as products of powers of these (derived dimensions). Currency may also be taken to be a base dimension in some fields such as economics.
A system of units is a collection of units which assign specific standards of measure (units) to a set of base and derived dimensions. Knowing the dimension of that which is being measured already goes a long way to helping conversions of units. The International System of Units (SI) is one such system of units used to describe physical phenomena and has been chosen to be the standard of such measurement.
If the dimension of a unit and the conversion of that unit to SI (see SI conversion factor ) are known, then converting the given information to any other system of units is straight forward so long as the conversion from SI to the target unit is known.
For example, 4.37 yds may be encoded as:
<apply> <times/> <cn type='real'>4.37</cn> <semantics definitionURL='http://.../units/'> <csymbol definitionURL='http://.../units/yard'>yds</csymbol> <annotation definitionURL='http://.../dimension/length'/> <annotation-xml encoding='MathML' definitionURL='http://.../SI-conversion-factor'> <cn type='real'>0.9144</cn> </annotation-xml> </semantics> </apply>
Thus, any application reading this data and wishing to convert it to cgs need only extract the dimension, the conversion factor, and look up the appropriate conversion of the unit of length in SI (m) to the unit of length in cgs (cm) to get 4.37 yds = 400 cm.
The dimension may also be used to encode information which may be lost in the
representation. For example, while a reasonable SI unit of torque is the
J/rad
, it is common to use the unit N m
where the second unit is understood to be a radial measure. Some other examples of units
which may be used to represent different quantites are:
| Unit | Possible Quantities |
|---|---|
| coulomb | electric charge, quantity of electricity |
| volt | electric potential difference, electromotive force |
| watt | power, radiant flux |
| newton meter | energy, torque |
A list of possible dimensions is given in C Dimensions.
In this case, the annotation-xml
element is the SI equivalent unit, and
gives a MathML encoding of the equivalent SI unit. This annotation is redundant if the
dimension of the unit is given, as the conversion from
the dimension to the equivalent unit is a matter of a table look up, though it may be used
if an unnamed dimension is being used. For example, the rate of change of power per unit
of time is an unnamed dimension, thus, for example, one encoding of 30.523 Hp/min may be:
<apply> <times/> <cn type='real'>30.523</cn> <semantics definitionURL='http://.../units/'> <apply> <divide/> <csymbol definitionURL='http://.../units/horsepower'>Hp</csymbol> <csymbol definitionURL='http://.../units/minute'>min</csymbol> </apply> <annotation-xml encoding='MathML' definitionURL='http://.../SI-equivalent-unit'> <apply> <divide/> <csymbol definitionURL='http://.../units/watt'>W</csymbol> <csymbol definitionURL='http://.../units/second'>s</csymbol> </apply> </annotation-xml> <annotation-xml encoding='MathML' definitionURL='http://.../SI-conversion-factor'> <cn type='real'>12.428331193037837</cn> </annotation-xml> </semantics> </apply>
A system of units is a collection of base units and products of powers of those units used to measure various physical phenomena.
A system of units is said to be self-consistent if any two products of units within that system which have the same dimensions are equal. For example, SI is consistent while UK and US systems systems of units are not. For example, in either system, the unit of power, the Hp, is not equal to the compound unit lb·ft2/s3. Neither is the unit of force, the pound-force, equal to the compound unit lb·ft/s2.
In general, the system annotation should only be used when the system is self-consistent. The following systems are self consistent:
| System Name | Annotation |
|---|---|
| International System of Units | <annotation definitionURL='http://.../system/SI'/> |
| Centimeter-Gram-Second | <annotation definitionURL='http://.../system/cgs'/> |
| Electrostatic System of Units | <annotation definitionURL='http://.../system/esu'/> |
| Electromagnetic System of Units | <annotation definitionURL='http://.../system/emu'/> |
| Atomic System of Units | <annotation definitionURL='http://.../system/atomic'/> |
The system annotation should be used if the unit is either the default unit in the given system for the particular dimension, or is equal to that unit.
For example, the system annotation may be used for either J or kg·m2/s2
but should not be used for kJ. All three could use the energy dimension annotation, but the
first two would use the SI system annotation whereas the latter would use the SI conversion
factor XML
annotation with content <cn type="integer">1000</cn>
.
Due to the ubiquitous nature of the foot-pound-second system of units in some countries some mention of this system of units is necessary. It is recommended that the dimension and SI conversion factor annotations be used. Some conversion factors between the fps system and SI are provided in the following table. Exact conversions are marked in bold.
| Name | Symbol | SI Equivalent Unit | Conversion Factor |
|---|---|---|---|
| foot | ft | m | 0.3048 |
| pound | lb | kg | 0.45359237 |
| poundal | pdl | N | 0.138254954376 |
| pound-force | lbf | N | 4.4482216152605 |
| horsepower | Hp | W |<PHONE_NUMBER>8227022 |
| pound(-force)s per square inch | psi | Pa | 6894.757293 |
The conversions of most other fps units may be found by taking products of powers of the above conversion factors.
The SI conversion factor annotation-xml
encoding
is a MathML encoding of the conversion factor between that unit and the equivalent SI
unit of the same dimension. In the previous example, the
conversion from lbf·ft to J/rad is<PHONE_NUMBER>828501/2500000000000000 = 1.3558179483314004.
Some examples of using units with the semantics encoding are:
980.665 cm/s
<apply> <times/> <cn type='real'>980.665</cn> <semantics definitionURL='.../units'> <apply> <times/> <csymbol definitionURL='.../units/meter#c'>cm</csymbol> <csymbol definitionURL='.../units/second'>s</csymbol> </apply> <annotation definitionURL='http://.../dimension/speed'/> <annotation definitionURL='http://.../system/cgs'/> <annotation-xml encoding='MathML' definitionURL='http://.../SI-conversion-factor'> <cn type='rational'>1</sep>100</cn> </annotation-xml> </semantics> </apply>
1 atm = 103.325 kPa
<apply> <eq/> <apply> <times/> <cn type='integer'>1</cn> <semantics definitionURL='http://.../units/'> <csymbol definitionURL='http://.../units/atmosphere'>atm</csymbol> <annotation definitionURL='http://.../dimension/pressure'/> <annotation-xml encoding='MathML' definitionURL='http://.../SI-conversion-factor'> <cn type='integer'>101325</cn> </annotation-xml> </semantics> <cn type='integer'>1</cn> </apply> <apply> <times/> <cn type='real'>101.325</cn> <semantics definitionURL='http://.../units/'> <csymbol definitionURL='http://.../units/pascal#k'>kPa</csymbol> <annotation definitionURL='http://.../dimension/pressure'/> <annotation-xml encoding='MathML' definitionURL='http://.../SI-conversion-factor'> <cn type='integer'>1000</cn> </annotation-xml> </semantics> </apply> </apply>
The fuel efficency of some cars is as good as 4.4 L/(100 km).
<mrow> <mn>4.4</mn> <mo></mo> <mfrac> <mi>L</mi> <mrow> <mn>100</mn> <mo></mo> <mi mathvariant='normal' class='MathML-Unit'>km</mi> </mrow> </mfrac> </mrow>
<apply> <times/> <cn type='real'>4.4</cn> <semantics> <apply> <divide/> <csymbol definitionURL='http://.../units/liter'>L</csymbol> <apply> <times/> <cn type='integer'>100</cn> <csymbol definitionURL='http://.../units/meter#k'>km</csymbol> </apply> </apply> </semantics> </apply>
The first editor would like to thank Stan Devitt, Robert Miner, Max
Froumentin, Laurent Bernardin, and Jacques Carette for helping me with this Note. In
particular, Dr. Devitt suggested the use of the
semantics
element for isolating a unit, and Dr. Miner helped initiate the Note. The first editor would also like to
thank Jeff Giles for additional comments.
Prefixes are used to form names and symbols of decimal or binary multiples and decimal submultiples of units. These prefixes or their symbols are attached to names or symbols, forming what are called multiples and submultiples of units.
SI prefixes are used to represent decimal multiples and submultiples of units. As 103 = 1000 ˜ 1024 is approximately equal to 210, it has been common to use SI prefixes to represent binary multiples of information units, though this is not universal. For example, in referring to the bit rates of a modem, the prefixes indicate powers of 10, not 2. The IEC introduced binary prefixes in 1998 to correct the confusion resulting from this.
| Multiplication Factor | Prefix | Symbol | Example |
|---|---|---|---|
| 1024 | yotta | Y | <csymbol definitionURL="http://.../units/meter#Y">Ym</csymbol> |
| 1021 | zetta | Z | <csymbol definitionURL="http://.../units/meter#Z">Zm</csymbol> |
| 1018 | exa | E | <csymbol definitionURL="http://.../units/meter#E">Em</csymbol> |
| 1015 | peta | P | <csymbol definitionURL="http://.../units/meter#P">Pm</csymbol> |
| 1012 | tera | T | <csymbol definitionURL="http://.../units/meter#T">Tm</csymbol> |
| 109 | giga | G | <csymbol definitionURL="http://.../units/meter#G">Gm</csymbol> |
| 106 | mega | M | <csymbol definitionURL="http://.../units/meter#M">Mm</csymbol> |
| 103 = 1000 | kilo | k | <csymbol definitionURL="http://.../units/meter#k">km</csymbol> |
| 102 = 100 | hecto | h | <csymbol definitionURL="http://.../units/meter#h">hm</csymbol> |
| 101 = 10 | deka | da | <csymbol definitionURL="http://.../units/meter#da">dam</csymbol> |
| 10-1 = 0.1 | deci | d | <csymbol definitionURL="http://.../units/meter#d">dm</csymbol> |
| 10-2 = 0.01 | centi | c | <csymbol definitionURL="http://.../units/meter#c">cm</csymbol> |
| 10-3 = 0.001 | milli | m | <csymbol definitionURL="http://.../units/meter#m">mm</csymbol> |
| 10-6 | micro | μ | <csymbol definitionURL="http://.../units/meter#u">μm</csymbol> |
| 10-9 | nano | n | <csymbol definitionURL="http://.../units/meter#n">nm</csymbol> |
| 10-12 | pico | p | <csymbol definitionURL="http://.../units/meter#p">pm</csymbol> |
| 10-15 | femto | f | <csymbol definitionURL="http://.../units/meter#f">fm</csymbol> |
| 10-18 | atto | a | <csymbol definitionURL="http://.../units/meter#a">am</csymbol> |
| 10-21 | zepto | z | <csymbol definitionURL="http://.../units/meter#z">zm</csymbol> |
| 10-24 | yocto | y | <csymbol definitionURL="http://.../units/meter#y">ym</csymbol> |
| Multiplication Factor | Full Technical Name | Prefix | Symbol | Example |
|---|---|---|---|---|
| 260 | exabinary | exbi | Ei | <csymbol definitionURL="http://.../units/byte#Ei">EiB</csymbol> |
| 250 | petabinary | pebi | Pi | <csymbol definitionURL="http://.../units/byte#Pi">PiB</csymbol> |
| 240 | terabinary | tebi | Ti | <csymbol definitionURL="http://.../units/byte#Ti">TiB</csymbol> |
| 230 | gigabinary | gibi | Gi | <csymbol definitionURL="http://.../units/byte#Gi">GiB</csymbol> |
| 220 | megabinary | mebi | Mi | <csymbol definitionURL="http://.../units/byte#Mi">MiB</csymbol> |
| 210 | kilobinary | kibi | Ki | <csymbol definitionURL="http://.../units/byte#Ki">KiB</csymbol> |
This appendix contains a list
of suggested values for the definitionURL
element for dimensions which may be used in the dimension annotation
of a semantics group. Also listed is the standard SI unit of that dimension.
Fragment identifiers are not used, as indices into the dimension pages may later be
used to identify, for example, the SI unit, e.g., http://.../dimension/length#SI
| Dimension | Definition URL | SI Unit |
|---|---|---|
| length | http://.../dimension/length | m |
| mass | http://.../dimension/mass | kg |
| time | http://.../dimension/time | s |
| electric current | http://.../dimension/electric_current | A |
| thermodynamic temperature | http://.../dimension/thermodynamic_temperature | K |
| amount of substance | http://.../dimension/amount_of_substance | mol |
| luminous intensity | http://.../dimension/luminous_intensity | cd |
| amount of information | http://.../dimension/amount_of_information | B |
| plane angle | http://.../dimension/plane_angle | rad |
| solid angle | http://.../dimension/solid_angle | sr |
| electric capacitance | http://.../dimension/electric_capacitance | F |
| electric charge | http://.../dimension/electric_charge | C |
| electric conductance | http://.../dimension/electric_conductance | S |
| electric inductance | http://.../dimension/electric_inductance | H |
| electric potential difference | http://.../dimension/electric_potential_difference | V |
| electric resistance | http://.../dimension/electric_resistance | Ω |
| energy | http://.../dimension/energy | J |
| force | http://.../dimension/force | N |
| frequency | http://.../dimension/frequence | Hz |
| illuminance | http://.../dimension/illuminance | lx |
| luminous flux | http://.../dimension/luminous_flux | lm |
| magnetic flux | http://.../dimension/magnetic_flux | Wb |
| magnetic flux density | http://.../dimension/magnetic_flux_density | T |
| power | http://.../dimension/power | W |
| pressure | http://.../dimension/pressure | Pa |
| Dimension | Definition URL | Example Compound SI Unit |
|---|---|---|
| absorbed dose rate | http://.../dimension/absorbed_dose_rate | Gy/s |
| acceleration | http://.../dimension/acceleration | m/s2 |
| action | http://.../dimension/action | kg·m2/s |
| angular acceleration | rad/s2 | |
| angular speed | http://.../dimension/angular_speed | rad/s |
| area | http://.../dimension/area | m2 |
| concentration | http://.../dimension/concentration | mol/m3 |
| current density | http://.../dimension/current_density | A/m2 |
| dynamic viscosity | http://.../dimension/dynamic_viscosity | Pa·s |
| electric charge density | http://.../dimension/electric_charge_density | C/m3 |
| electric field strength | http://.../dimension/electric_field_strength | V/m |
| electric flux density | http://.../dimension/electric_flux_density | C/m2 |
| energy density | http://.../dimension/electric_density | J/m3 |
| entropy | http://.../dimension/entropy | J/K |
| exposure | http://.../dimension/exposure | C/kg |
| heat capacity | http://.../dimension/heat_capacity | J/K |
| heat flux density | http://.../dimension/heat_flux_density | W/m2 |
| irradiance | http://.../dimension/irradiance | W/m2 |
| kinematic viscosity | http://.../dimension/kinematic_viscosity | m2/s |
| linear frequency | http://.../dimension/linear_frequence | 1/(m·s) |
| linear mass density | http://.../dimension/linear_mass_density | kg/m |
| luminance | http://.../dimension/luminance | cd/m2 |
| magentic field strength | http://.../dimension/magentic_field_strength | A/m |
| mass density | http://.../dimension/mass_density | kg/m2 |
| molar energy | http://.../dimension/molar_energy | J/mol |
| molar entropy | http://.../dimension/molar_entropy | J/(mol·K) |
| molar heat capacity | http://.../dimension/molar_heat_mass | J/(mol·K) |
| moment of force | http://.../dimension/moment_of_force | J/rad |
| moment of inertia | http://.../dimension/moment_of_inertia | kg·m2 |
| momentum | http://.../dimension/momentum | kg·m/s |
| permeability | http://.../dimension/permeability | H/m |
| permittivity | http://.../dimension/permittivity | F/m |
| power density | http://.../dimension/power_density | W/m2 |
| radiance | http://.../dimension/radiance | W/(m2·sr) |
| radiant intenstiy | http://.../dimension/radiant_intensity | W/sr |
| specific heat capacity | http://.../dimension/specific_heat_capacity | J/(kg·K) |
| specific energy | http://.../dimension/specific_energy | J/kg |
| specific entropy | http://.../dimension/specific_entroy | J/(kg·K) |
| specific volume | http://.../dimension/specific_volume | m3/kg |
| surface energy density | http://.../dimension/surface_energy_density | J/m2 |
| surface power density | http://.../dimension/surface_power_density | W/m2 |
| surface tension | http://.../dimension/surface_tension | N/m |
| thermal conductivity | http://.../dimension/thermal_conductivity | W/(m·K) |
| speed | http://.../dimension/speed | m/s |
| volume | http://.../dimension/volume | m3 |
| volume flow | http://.../dimension/volume_flow | m3/s |
| wave number | http://.../dimension/wave_number | 1/m |


XML overuse? (was Re: Python to XML to Python conversion)
Clark C . Evans
cce at clarkevans.com
Thu Jul 18 15:26:48 CEST 2002
On Wed, Jul 17, 2002 at 11:52:50PM +0100, James Kew wrote:
| > The information model fits documents well, but is a poor match
| > for object serialization, which is 90% of the use cases
| > programmers face.
|
| Um: 90%? What sort of use cases do you see programmers forcing XML into?
| Just curious: I fall into the "XML as poor-man's database/parser" camp at
| the moment but I'm finding that for a poor man's solution it does quite a
| good job with not much programmer effort to glue it together.
XML has its roots in structured document processing, and is a
descendent of SGML. For example, the research reports by Gartner Group
are primarly text, but there are specific tags to mark-up features of
the report: chapters to generate a table of contents, keywords to make
an index, vendor names to enable better searching, etc. The reports
are highly structured with tags, each tag having a beginning and an
ending. Furthermore, there is also information which must be attached to
a particular series of characters, such as an editorial comment, but must
not appear in print. All in all, structured document processing is
a rather complicated beast and SGML set out to tackle this problem.
SGML thus had many features which supported these requirements. It had
attributes for out-of-band information which must be attached to a sequence
of characters but not be printed. It allows for mixed content, so that
a paragraph for instance can contain a series of untagged characters
followed by a series of characters tagged bold. Also, SGML allows for
named lists, so that a chapter could be defined, for example, as a series
of tables, paragraphs and figures. SGML is also character based, since
documents are in essence a large blob of characters "marked-up"
SGML also had lots of features which enabled human-editing, it allowed
you to skip end tags, it even allowed you to skip intermediate tags
so that if a chapter couldn't contain characters directly (characters
must be wrapped with a paragraph) the parser would implicitly include
a paragraph anyway. These extra syntax features did wonders for SGML's
flexibility and in no small way were responsible for HTML's success.
However, the implicit and missing end tags required that a parser know
the document type definition before it could parse an SGML text. Further,
these implicit thingys made it hard to write parsers.
Therefore, there was a simplification movement in HTML land where
the strcutral features (attributes, mixed content, named list) components
of SGML were kept but the features which required a DTD and made
parsing complex (implicit tags, optional end tags, etc) were dropped.
This simplified SGML was dubbed XML and was then markeded as
HTML-next-generation. The marketing for XML has been enormous, but
at it's core, it is still primarly a structured document markup language.
Due to XML's popularity, lots of people have tried to get it to work
for other things. A few people have made XML databases and others
have used XML for object serialization and invocation (SOAP/XML-RPC)
and it has had many other uses. However, most of these uses tend to
use a vastly simplified subset of XML and indeed impose additional
constraints on XML as far as particular attributes, etc. These
additional attributes/constrains are often needed to model native
datastructures of modern languages and they include: (a) a way to
specify node type, (b) a way to express that a node occurs more than
once in the graph-serialized-as-a-tree, (c) a manner to restrict
mixed content which does not usually occur in modern languages, (d)
restrictions on named list model are also common.
However, even with these constraints and fix-ups, at its heart,
XML is a much more complicated beast and this complexity is reflected
in the DOM and SAX interface. Since this is the primary interface
used by programmers, programmers must grapple with documentisms
even if they don't need structured document features.
In summary, I'm not saying that XML is bad. It's is fantastic for
structured document processing (I have direct experience here). However,
just beacuse it has had great success in this domain doesn't mean that
this success will be long-lasting in other domains. I see people
using XML for lots of purposes it was never designed for; certainly
it is flexible enough to do it, but the question is: At what price?
With XML the price is pretty steep, especially for "object serialization"
requirements where attributes, mixed-content, and named-lists arn't
needed and where other things such as typing, graph links, map/lists,
and treating characters as a whole scalar (rather than as chunks
of characters) is what you want.
So, that said, YAML (YAML Ain't Markup Language, http://yaml.org) was
designed to meet the needs of object serialization directly. In this
domain, I must say, it is much much better than XML. Just like in the
document serialization domain for which XML was designed, YAML would
not work very well at all... YAML isn't markup. In YAML you have
dictionaries, lists, and scalars; you don't have chararacters that
are tagged. The difference may seem subtle, but the actual impact
is huge. It's a completely different mid-set. For a programmer with
serialization needs, YAML fits the bill perfectly while XML requires
quite a bit of effort to make work.
The only down side of YAML is that it isn't buzz-word compliant and
the implementation's aren't quite mature yet. The implementations will
come along (the native python one isn't bad at all). And hopefully
buzz-word compliance will come along eventually, till then there is
a subsetted XML mapping of YAML (http://yaml.org/xml.html) which
you can use. I'll patch up the python parser to read/write from
this XML format within a few more weeks. This way those team
members which have to have to be buzz-word compliant can do so.
For my day job, I'm more interested in getting the job done...
Best,
Clark
More information about the Python-list
mailing list


$1st PLACE |
$2nd PLACE |
$1st PLACE |
$2nd PLACE |
$3rd PLACE |
$4th PLACE |
$5th PLACE |
|||
|
Reliability Bonus |
CHECKPOINT AWARDS WORTH EACH NO CHECKPOINT AWARDS |
||||||||
|
Points |
{{CD.challenge.postingDate | formatDate:2}}
{{CD.challenge.registrationEndDate | formatDate:2}}
{{CD.challenge.submissionEndDate | formatDate:2}}
{{CD.challenge.currentPhaseEndDate | formatDate:2}}
{{CD.challenge.finalFixEndDate | formatDate:2}}
{{CD.challenge.postingDate | formatDate:2}}
{{CD.challenge.checkpointSubmissionEndDate | formatDate:2}}
{{CD.challenge.submissionEndDate | formatDate:2}}
{{CD.challenge.appealsEndDate | formatDate:2}}
Challenge Overview
Platforms
- {{platform}}
- Not Specified
Technologies
- {{tech}}
- Not Specified
Final Submission Guidelines
Payments
Topcoder will compensate members in accordance with the our standard payment policies, unless otherwise specified in this challenge. For information on payment policies, setting up your profile to receive payments, and general payment questions, please refer to https://help.topcoder.com/hc/en-us/articles/217482038-Payment-Policies-and-Instructions
Reliability Rating and Bonus
For challenges that have a reliability bonus, the bonus depends on the reliability rating at
the moment of registration for that project. A participant with no previous projects is
considered to have no reliability rating, and therefore gets no bonus.
Reliability bonus does not apply to Digital Run winnings. Since reliability rating is
based on the past 15 projects, it can only have 15 discrete values.
Read more.
CHALLENGE SUMMARY
Please read the challenge specification carefully and watch the forums for any questions or feedback concerning this challenge. It is important that you monitor any updates provided by the client or Studio Admins in the forums. Please post any questions you might have for the client in the forums.
CHALLENGE FORMAT
This competition will be run as a two-round challenge.
Round Two (2)
Regarding the Rounds:
- To be eligible for Round 1 prizes and design feedback, you must submit before the Checkpoint deadline.
- A day or two after the Checkpoint deadline, the challenge holder will announce Round 1 winners and provide design feedback to those winners in the "Checkpoints" tab above.
- You must submit to Round 1 to be eligible to compete in Round 2. If your submission fails screening for a small mistake in Round 1, you may still be eligible to submit to Round 2.
- Every competitor with a passing Round 1 submission can submit to Round 2, even if they didn't win a Checkpoint prize.
- Learn more here.
FULL DESCRIPTION & PROJECT GUIDE
STOCK PHOTOGRAPHY
Stock photography is allowed in this challenge.
See this page for more details.
Stock photography is not allowed in this challenge. All submitted elements must be designed solely by you.
See
this page for more details.
HOW TO SUBMIT
- New to Studio? Learn how to compete here.
- Upload your submission in three parts (Learn more here). Your design should be finalized and should contain only a single design concept (do not include multiple designs in a single submission).
- If your submission wins, your source files must be correct and "Final Fixes" (if applicable) must be completed before payment can be released.
- You may submit as many times as you'd like during the submission phase, but only the number of files listed above in the Submission Limit that you rank the highest will be considered. You can change the order of your submissions at any time during the submission phase. If you make revisions to your design, please delete submissions you are replacing.
WINNER SELECTION
Submissions are viewable to the client as they are entered into the challenge. Winners are selected by the client and are chosen solely at the Client's discretion.
PAYMENTS
Topcoder will compensate members in accordance with the our standard payment policies, unless otherwise specified in this challenge. For information on payment policies, setting up your profile to receive payments, and general payment questions, please refer to https://help.topcoder.com/hc/en-us/articles/217482038-Payment-Policies-and-Instructions
Reliability Rating and Bonus
For challenges that have a reliability bonus, the bonus depends on the reliability rating at
the moment of registration for that project. A participant with no previous projects is
considered to have no reliability rating, and therefore gets no bonus.
Reliability bonus does not apply to Digital Run winnings. Since reliability rating is
based on the past 15 projects, it can only have 15 discrete values.
Read more.


Clock
Stoper
Workout
Calendar
<
>
Series
Workouts
Seconds
Rest between
series
Rest between
workout
START
STOP
R
Series
Workouts per Series
Seconds per Workouts
Rest between
series
Rest between
workout
START
STOP
R


[ht::head {Creating and Managing Users}]
You can create and edit user accounts through the
Admin Users
section.
Lets create a couple of user accounts.
- Press New User
- In the form specify the user information. For this exercise
specify "user1" as the ID. Under Roles specify "test". Specify a
easily remembered password for this exercise.
- You can optionally create a new Folder that the user
will own. Select the People folder.
- If you had email enabled for your RAMADDA you can also choose to send an
email with the login information.
- Press "Create User"
From the main user list you can view their activity () or
edit their account settings (img src="images/edit.png">)
Edit your new user1 account.
[ht::foot]


Our mission is to create a library of information and rescources for anyone looking to explore the ever evolving Chicago tech industry. By providing connections to events, education opportunities, and job openings we hope to provide the tools needed to face any challenge.
With how quickly the tech field continues to expand, there are ample learning rescources for both newcomers and veterans. Jump headfirst into our listings to find anything from a day one tutorial to a list of new tricks or forgotten gems for established coders.
Coding involves heavy collaboration and social interaction, what better way to get your feet wet than attending one of the many events around town. Pros in the industry are always giving talks on a wide range of subjects in the field, meetups offer chances to network every day of the week, and workshops pop up all the time.
The end goal: gainful employment in this ever growing and always relevant field. We've partnered with career search engines such as Github Jobs to let you pull up local openings in the same convenient space as our other resources. Utilize our search function to cater the listings towards your particular skillset.


{% include "navbar.html" %}
Login
Username:
Password:
if you don't have an account you can
register here
{% include "footer.html" %}


The block diagram shows the motif matches comprising a motif cluster detected by MCAST.
A selected portion of the input sequence with the matching motifs displayed above it.
For each matching motif the strand of the match (+/-), the consensus sequence of the motif, the p-value of the individual motif match (see also help button for "Cluster Score") and the sequence logo of the motif is shown.
You can select the portion of the sequence to be displayed by sliding the two buttons below the sequence block diagram so that the portion you want to see is between the two needles attached to the buttons. By default the two buttons move together, but you can drag one individually by holding shift before you start the drag.
| Motif | 1 |
|---|---|
| p-value | 8.23e-7 |
| Start | 23 |
| End | 33 |
Change the portion of annotated sequence by dragging the buttons; hold shift to drag them individually.
For further information on how to interpret these results or to get a copy of the MEME software please access http://meme-suite.org.
If you use MCAST in your research please cite the following paper:
Timothy Bailey and William Stafford Noble,
"Searching for statistically significant regulatory modules",
Bioinformatics (Proceedings of the European Conference on Computational Biology),
19(Suppl. 2):ii16-ii25, 2003.
[full text]
The following sequence databases were supplied to MCAST.
| Database | PSP/Wig file | PSP Distribution file | Sequence Count | Letter Count |
|---|
The following motif databases were supplied to MCAST.
| Database |
|---|
Which contained the following motifs.


Meet Arken, A Decentralized Archival Cluster Built for the World's Most Important Data.
- Used Space: {{.UsedSpace}} TB
- Total Space: {{.TotalSpace}} TB
- Active Nodes: {{.ActiveNodes}}
- Gitub: arkenproject/arken
- Dockerhub: arkenproject/arken
A bit of Backstory
Many researchers, museums, and archivists are struggling to host and protect a vast amount of important public data.
On the other hand, there are many of us developers, tinkerers, and general computer enthusiasts who have extra storage
space on our home servers.
The goal of Arken is to build an autonomous system for organizing, balancing, and distributing this data among users who
can donate their extra space.
What is Arken?
Arken is a management engine that runs on top of the IPFS (Interplanetary File System) protocol. Each instance of Arken calculates which important files are hosted by the fewest number of other nodes on the network and should thus be locally backed up to reduce the risk of data loss. Arken also knows how much space it's using on your system and will respect limits you set by locally deleting data that is backed up by more than 10% of the cluster.
Keyset Security
Since Keysets are openly available through Git repositories, they can be easily audited but can only be changed by users who have access to those Git repositories or through pull requests.
Want to read more about Arken?
Check out the Project's Github Page.


You will learn how to create your own functions, invoking functions, accepting parameters, and returning values.
In Zen, all your programs are built with classes, which means there is at least
one class. Further, every program must have at least one function, the main()
function. That is it. Beyond that, you do not need to create other functions.
But, without functions, often your code will contain a lot of duplicate instructions.
A function is a block of statements. You can give it a name. When a function is declared inside a class, it defines an object’s behavior, basically whatever an object is capable of performing.
You can call or invoke a function with its name. When you invoke a function, the execution of your program branches to the body of that function. When the function is finished, execution resumes from where the program branched, and the program continues on to the next statement.
You have already used functions. For example, print
and scan
are
functions declared in the ZenHelper
class.
The primary advantages of functions are as follows.
- Functions improve the quality of your code. They make it more readable because you break your code into logical chunks.
- You avoid duplicate code. Imagine you are writing an application that simulates an airplane, which requires primitive matrix operations such as addition, subtraction and multiplication. Without functions you would have to write these operations in several places. So whenever you see yourself writing the same code, it is a good idea to write a function.
- You can implement polymorphism through functions. This is one of the most important features of functions.
Declaring Functions
Here is the general form of a function declaration.
function name(parameters)
statement1
statement2
...
statementN
The name of your function helps you call it.
Here is an example of a program which has redundant statements. Apparently, Harry and Hermione are on an adventure, trying to break into a mysterious tower. The following program prints the dialogue between them.
// MysteryTower.zen
function main(...arguments)
print('Harry Potter: Can you open this door?')
print('Hermione Granger: Alohomora!')
print('Harry Potter: Can you open this door?')
print('Hermione Granger: Alohomora!')
print('Harry Potter: Can you open this door?')
print('Hermione Granger: Alohomora!')
print('The door opens!')
In this example, your program prints the same messages three times. But then you end up writing the same statements over and over. Of course, you could rewrite this program with a loop. Alternatively, you could use a function.
Here is another version of the previous example using a function.
// MysteryTower2.zen
function openDoor()
print('Harry Potter: Can you open this door?')
print('Hermione Granger: Alohomora!')
function main(...arguments)
openDoor()
openDoor()
openDoor()
print('The door opens!')
The order in which you declare your functions does not matter. So in this example,
you could write the openDoor()
function after the main()
function, it would
not matter. Your program will execute the same.
// MysteryTower3.zen
function main(...arguments)
openDoor()
openDoor()
openDoor()
print('The door opens!')
function openDoor()
print('Harry Potter: Can you open this door?')
print('Hermione Granger: Alohomora!')
When you invoke openDoor(), the two print statements in the openDoor()
function
are executed sequentially. After which the control returns back to where the
function was called.
Naming Conventions for Functions
- Begin function names with a lowercase letter. For example,
print
,getName
,setTitle
andbuffer
. - If the function name consists of more than one word, capitalize every word,
except the first word. For example,
toString
,initializeCamera
,launchRocket
andparseInteger
. - Try to begin your function names with verbs. The name of a function should indicate an action.
Working with Parameters
A parameter is a value that you can send to a function. Parameters allow a function to be generalized. In other words, such functions can operate on a variety of data and work differently based on different arguments.
It is important to understand the difference between parameters and arguments. A parameter is a variable defined by a function that receives a value when the function is invoked. Whereas, an argument is the value that is passed to a function when it is invoked.
You must list your parameters when you declare your function. The parameters are listed in the parentheses after your functions name. Every parameter should have a name. You can pass values to your function when you call it. List your values in the parentheses after your functions name.
Consider the following example.
function square()
print(7 * 7)
The square()
function prints the square of 7
. Although this function works
perfectly, it is very limited. However, if you modify the function to accept a
parameter, you can make it more useful and flexible.
function square(number)
var result = number * number
print(result)
You can use a parameter like any other local variable. Its value is initialized with the value you pass.
For example, you can call square
like this.
square(5)
If you need more than one parameter, you must separate them with commas.
Here is an example.
void createUser(name, age)
...
You can call createUser
like this:
createUser('Sherlock Holmes', 24)
If your function needs no parameters, leave the parentheses empty.
Here is an example.
function collect()
...
You can call collect
like this:
collect()
Understanding Scope of Parameters
The parameters of your function exists only within the function. You cannot access it outside your function.
// Calculator.zen
function main(...arguments)
var x = 10
var y = 20
var result = add(x, y)
printf('%d + %d = %d\n', x, y, result)
function add(x, y)
return x + y
In ‘main, we declared three variables named
x,
yand
result. We call
add()to compute the sum of
xand
y. The
add()function accepts two parameters named
xand
y`.
The local variables in main
and the parameters in add
have the same names.
Compile this program. The compiler does not complain. But why? The compiler
generate errors if we declare variables with the same name, right? As we told
earlier, parameters exist only within the function they are declared. Local
variables exist only within the block they are declared. This is why the compiler
does not generate any error. In other words, the local variables x
and y
declared in the main()
function and the parameters x
and y
declared in the
add()
function exist in different scopes.
Understanding Functions That Return Values
Functions that perform operations without returning any value are useful, but this is not the case always. In this section you will learn how to return values from functions.
Imagine that you write a function that accepts your date of birth and calculates your age. Probably the function can print it on the console. But this is not what you always want. For example, you would want the calculated age to determine if you are eligible to vote, or not. In such cases, your function needs to return a value or store the result in some field. Usually, returning a value is much easier. You can use the return statement to return a value to the caller.
Here is the general form of the return statement.
return expression
The expression must evaluate to a value which will be returned by the function. You cannot return more than one result at a time. Further, the function terminates as soon the return statement is executed. Improper use of return statements create unreachable regions in your function causing bugs. We recommend you to design your functions to always use a minimum number of return statements. This way you can easily determine the exit points of your function.
Here is an example of a function that accepts a number and determines if it is even, or not.
// OddOrEven.zen
function isEven(number)
if number % 2 == 0
return true
else
return false
function main(...arguments)
var n = 19
var result = isEven(n) ? 'even' : 'odd'
printf('%d is %d.\n', n, result)
Here, the isEven()
function accepts an integer value. It then divides it by 2 for
remainder. If the remainder is 0
, it returns true
indicating an even number.
Otherwise, it returns false
indicating an odd number.
Here is another version of the isEven
function.
// OddOrEven2.zen
function isEven(number)
return number % 2 == 0
function main(...arguments)
var n = 19
var result = isEven(n) ? 'even' : 'odd'
printf('%d is %s.\n', n, result)
Here is an example of the isEven()
function, which would generate
an error.
function isEven(number)
if number % 2 == 0
return true
In this example, the function does not return a value in all cases. If the specified number was odd, the function would not return any value, but the compiler expects you to return a value in all cases. This is why it would generate errors if you tried to feed code like this. You should be careful when you return values from loops and conditional statements. You need to ensure that a value is returned in all case.
Here is an example of a program that computes the factorial of a number.
// Factorial.zen
function factorial(number)
var result = 1
for i in range(2, number + 1)
result *= i
return result
function main(...arguments)
var n = promptInteger('Enter an integer: ')
var result = factorial(n)
printf("%d! = %d\n", n, result)
Function Overloading
Unlike variables, multiple functions in the same scope can have the same name. This technique is known as function overloading. It is a feature of polymorphism. Function overloading is a very useful feature.
Zen differentiates functions using pseudo function signatures. A pseudo function signature is a part of function declaration. It is the combination of the function name and the parameter count. The names of the parameters are not included in the pseudo function signature.
In order to overload a function, the pseudo function signatures should be different. Which means even if your function names are the same, you need to have different parameter counts. When the functions have the same name but different parameter counts, the functions are said to be overloaded. When you invoke an overloaded function, Zen uses the following conditions to determine which version of the overloaded function you are calling.
- The type of each argument you are passing.
- The number of arguments you are passing.
This is the reason why overloaded functions must have different parameter counts. Otherwise, Zen will not be able to determine which version of the overloaded function to call.
Here is a simple example that computes area of squares and rectangles using function overloading.
// AreaComputer.zen
/**
* Compute the area of a square.
*/
function computeArea(side)
return side * side
/**
* Compute the area of a rectangle.
*/
function computeArea(length, breadth)
return length * breadth
function main(...arguments)
var side = 10
var areaOfSquare = computeArea(side)
printf('The area of square with side %d is %d.\n', side, areaOfSquare)
var length = 10
var breadth = 5
var areaOfRectangle = computeArea(length, breadth)
printf('The area of rectangle with length %d and breadth %d is %d.\n', length, breadth, areaOfRectangle)
The output of this program is shown here.
The area of square with side 10 is 100.
The area of rectangle with length 10 and breadth 5 is 50.
As you can see, computeArea()
is overloaded two times. The first version accepts
a single parameter named side
. The second version accepts two parameters
named length
and breadth
, respectively. When you invoke a function, Zen
looks for a match between the arguments passed and the function parameters
declared.
When computeArea
is called the first time with a single integer argument,
the function which computes the area of a square is invoked. Similarly, when
computeArea
is called the second time with two integer arguments, the function
which computes the area of a rectangle is invoked. The results are respectively
stored in variables before printing.
Overloading is useful because it allows you to declare and invoke related functions
with the same name. For example, you could implement an operation such as
computeVelocity
, which obviously evalutes the velocity of an object, say a bike.
The name computeVelocity
represents the general action that is being performed.
You could implement two different versions of calculations using different formulas.
Assume one version accepts distance and time, whereas another version accepts force,
mass and time. With function overloading you could easily implement this. Otherwise,
you would have to come up with different names for each function.
When you overload a function, each version can implement anything. You do not have to relate the functions to one another. We recommend you to always overload functions that perform the same operation but in different ways.
Working with Getters and Setters
Object-oriented programming helps you hide the details of a class. You can expose certain parts of your class to others. You should generally avoid creating public fields. You can make all your fields private. You can give access to the values in these fields with accessors. Accessors are functions which access fields on the behalf of the world outside your class.
There are two types of accessors.
- Get Accessor
- Set Accessor
A get accessor is also known as getter. It is a function which gets the value
of a field. Similarly, a set accessor is also known as setter. It is a function
that sets the value of a field. Accessors are usually named getField
and
setField
. For example, for a field named age
, the accessors are named
getAge
and setAge
.
Here is an example.
class Rocket
var mass
var velocity
var acceleration
function setMass(m)
mass = m
function getMass()
return mass
function setVelocity(v)
velocity = v
function getVelocity()
return velocity
function setAcceleration(a)
acceleration = a
function getAcceleration()
return acceleration
In the above example, mass
, velocity, and
acceleration` are private fields.
You cannot access them directly outside the class. You need to use their accessors
instead.
Accessors have the following advantages over public fields.
- You can create read-only properties. You can provide only the getter but not a setter. Which means other classes can only read the property, but cannot write.
- You can avoid storing the value in a field. A getter can calculate the value.
Here is an example of a rectangle, where an accessor evaluates the value.
class Rectangle
var width
var height
function setWidth(w)
width = w
function getWidth()
return width
function setHeight(h)
height = h
function getHeight()
return height
function getArea()
return width * height
A setter can check if an invalid value is passed. It can throw an exception or provide a default value. You will learn more about exceptions later in this course.
For example, imagine you have a class Adult
. It has an integer property
named age
. Its value can be 18 or greater. You can write a setter which
ignores invalid values like this.
class Adult
...
var age
function setAge(a)
if a >= 18
age = a
function getAge()
return age
...
In fact, using accessors is actually a design pattern known as the Accessor Pattern. It is designed to provide a consistent way to read and write values of class fields while hiding the fields from the outside world. This pattern is very common because fields are usually private.
Using the Property Annotation
class Rocket
@Property
var mass
@Property
var velocity
@Property
var acceleration
class Rectangle
@Property
var width
@Property
var height
function getArea()
return width * height
Understanding Pass-By-Reference
When you pass a reference value, such as objects and arrays, as an argument to a function, the function receives a copy of the reference. In other words, the object itself is not copied when you pass it as an argument, only its reference is copied. Similarly, when you pass a variable that contains a reference to an object as an argument to a function, the function receives a copy of the reference, not the the variable itself. This technique is called pass-by-reference.
Pass-by-reference is applied when you pass reference values, such as objects and arrays. Therefore, if a function changes the reference it received through the parameter, it is not reflected in the original variable that was passed to the function. However, if the object is modified through the reference, then the change is reflected in the object. Because both the argument and the parameter refer to the same object, and not separate copies of the object.
Consider the following example.
// PassByReferenceDemo.zen
class Square
var side
function main(...arguments)
var square = new Square()
square.side = 5
printf('[before] square in main contains side = %d\n", square.side)
changeValue(square)
printf("[after] square in main contains side %d\n", square.side)
function changeValue(square)
square.side = 7
printf('square in changeValue contains side = %d\n", square.side)
The output of this example is shown here.
[before] square in main contains side = 5
square in changeValue contains side = 7
[after] square in main contains side = 7
In this example, a variable named square
is assigned an instance of the Square
class. The value of the side
field contained in the square
object is assigned
5
. It is then printed on the console. After which, Tthe changeValue()
function
is invoked with square
as its argument. Remember, the reference to the square
object is copied, not the object itself.
changeValue()
receives the reference as the parameter named square
.
It modifies the value of side
contained in the Square
object to 7
. After
which it prints out the value stored in it. When the changeValue()
function
terminates, the control is again transferred to main()
, where the current value
of side
is printed. Since the changeValue()
was invoked with a copy of the
reference, the square
object has been changed.


Created by Alan Shaw / @_alanshaw
Backed by couchdb
http://isaacs.iriscouch.com/registry
NoSQL, JSON documents, query using JavaScript & MapReduce, access via HTTP
It's just a node module. Use it programmatically.
var npm = require("npm")
npm.load({}, function (er) {
if (er) return console.error(er)
var cmdArgs = ["async"]
// Install the async module ...or do whatever - view, search, update, test
npm.commands.install(cmdArgs, function (er) {
if (er) return console.error(er)
console.log("async installed")
})
})
Configure all the things!
Configure all the things?
--foo=bar
NPM_CONFIG_FOO=bar
~/.npmrc
$PREFIX/npmrc
/path/to/npm/npmrc
Configure ALL the things?
Run your own npm ?
Get you an enterprise one from nodejitsu
npm link [module]
Create a globally installed symlink in node_modules/[module]
to /path/to/[module]
First:
cd /path/to/[module]
npm link
Then:
npm link [module]
# node_modules/[module] now symlinked to /path/to/[module]
The npm cache folder ~/.npm
cache-max
The maximum time (in seconds) to keep items in the registry cache before re-checking against the registry.
Default is infinity unless you...
npm cache clean
npm search [term]
...caches text in
~/.npm/-/all/.cache.json
...and searches through it with regular expressions
It's 14MB
npm tag <name>@<version> [<tag>]
Identify a version by name.
"latest" is an auto tag, that gets updated to point to the latest version
Depend on a version, a tag, an archive, or a git repo
{
"dependencies": {
"foo": "~1.2.3",
"bar": "latest",
"baz": "http://asdf.com/archive.tar.gz",
"boz": "git://github.com/user/project.git#commit"
}
}
npm version 1.2.3
It'll open up your package.json file, change the version to 1.2.3, git add it, git commit it, and git tag v1.2.3 it.
ERMAHGERD.


Before Change
main_project_doc.id,
main_project_entity.id])
cls.post_data = {"start_offset": 0, "end_offset": 10}
cls.count = SequenceAnnotation.objects.filter(document=main_project_doc).count()
def test_returns_entity_to_project_member(self):
self.client.login(username=self.project_member_name,
password=self.project_member_pass)
After Change
non_project_member = User.objects.create_user(username=cls.non_project_member_name,
password=cls.non_project_member_pass)
main_project = mixer.blend("server.Project", users=[project_member, another_project_member])
main_project_doc = mixer.blend("server.Document", project=main_project)
main_project_entity = mixer.blend("server.SequenceAnnotation",
document=main_project_doc, user=project_member)
another_entity = mixer.blend("server.SequenceAnnotation",
document=main_project_doc, user=another_project_member)
sub_project = mixer.blend("server.Project", users=[non_project_member])
sub_project_doc = mixer.blend("server.Document", project=sub_project)
mixer.blend("server.SequenceAnnotation", document=sub_project_doc)
cls.url = reverse(viewname="entity_detail", args=[main_project.id,
main_project_doc.id,
main_project_entity.id])
cls.another_url = reverse(viewname="entity_detail", args=[main_project.id,
main_project_doc.id,
another_entity.id])
cls.post_data = {"start_offset": 0, "end_offset": 10}
def test_returns_entity_to_project_member(self):
self.client.login(username=self.project_member_name,


Jinx is an ADC, or, Attack Damage Carry, in League of Legends. She is a hyper-scaling champion, meaning the longer the game progresses, the stronger she becomes.


Log file in Kodi is a kodi.log file, located in temporary directory. Location of that directory depends on the platform, and even on the same platform it can differ. Locations can be discovered here: https://kodi.wiki/view/Log_file/Advanced#Location
First of all, log file, by default, contains only limited records, only errors or some notable actions, but, to understand the cause of an issue, we need full log. So we need to enable debugging in Kodi.
That is it! But you probably won’t like the onscreen information about CPU usage and so on. So you can create an advancedsettings.xml file in Kodi’s Userdata folder (https://kodi.wiki/view/Userdata), which this content:
<?xml version="1.0" ?>
<advancedsettings>
<loglevel>2</loglevel>
<debug>
<extralogging>true</extralogging>
<showloginfo>false</showloginfo>
</debug>
</advancedsettings>
It will enable logging and hide onscreen information.
Now your Kodi records everything into the log file!
projectx has few HTTP links which can give you more information about torrenting status, system information, some timers of common operations (which are way too useful for developers!): - /debug/bundle will give you all the debug information + kodi.log file included. So it’s the fullest log file, and is what we’d expect from you to find the problem. - /debug/all contains all the debug information, without kodi.log, so it’s all about the system and torrent engine, but not Kodi.
To find proper link: - Enter projectx addon, open Status - In the table you can see the address, that can be opened from other devices (in case you Kodi runs on a separate device in the network)
If your projectx starts fine, so you can enter it, browse for something, then you can try this way, if not, please, browse for the Hard one.
There is bundled functionality to upload your /debug/bundle or /debug/all logs to pastebin services. All you need is to enter settings and start an upload:
Easy enough?!
Still not so hard, but, sadly, more manual and needs some effords, at least, for the first time. So you can follow the manual here: https://kodi.wiki/view/Log_file/Easy
Shortly, you can install log uploader plugin, and run it to get pastebin link of an uploaded log file. Or you can find your log location here: https://kodi.wiki/view/Log_file/Advanced#Location and use it manually.


Kalev, Fatih, Jake, Jack
Helping companies identify dope contracts to bid on, saving time and energy spent responding to RFPs.
Are you like Joe?
Be more like Bob!


Last updated: July 21, 2017
This document acts as an agreed upon Terms of Service ("Terms", "Terms of Service") between you (the "User" or "you") and TeaToken.io ("TeaToken"). You accept these Terms when you use TeaToken services or any other features, technologies or functionalities offered by TeaToken on TeaToken web-site at http://teatoken.io (the "Site") or through any other means (collectively, "Services"). The terms "us", "we", or "our" refer to TeaToken.
Your access to and use of the Service is conditioned on your acceptance of and compliance with these Terms. These Terms apply to all visitors, users and others who access or use the Service. We will provide notice of any amendment to these Terms by posting any revised terms to the site and updating the "Last updated" field above accordingly or by any other method we deem appropriate. We are not obligated to provide notice in any other method beyond these. Any change to these Terms will be effective immediately upon such notice and apply to any ongoing or subsequent use of the Site, Services, or Platform.
TeaToken provides online features (the "Platform") to allow users to easily conduct the issuance and management of blockchain, distributed ledger technology ("DLT"), or otherwise cryptographically secured tokens ("Tokens") - whether or not they are sometimes colloquially referred to as "cryptocurrencies."
By accessing or using the Service you agree to be bound by these Terms. If you disagree with any part of the terms then you may not access the Service.
The User represents and warrants that you are at least eighteen (18) years of age, are legally entitled to use the internet and services like those provided by TeaToken (according to the laws and any relevant jurisdiction in which you reside), and have not had your right to use our service previously suspended or revoked by us.
The User represents and warrants that you will not use the Site or Platform for any criminal, illegal, or otherwise prohibited use, including (but not limited to) activities related to money-laundering, drug trafficking, human trafficking, weapon trafficking, terrorism, securities fraud, or tax evasion. You represent and warrant that you will not use our platform to assist any other party in such illegal activity.
The User represents and warrants that you will not in any way use the Platform or Services to: distribute spam, junk communications or chain letters; reverse engineer or otherwise improperly access any of the Site's or the Platforms underlying code or technical mechanisms; cause damage to the Site or TeaToken through any means, including (but not limited to) through the use of hacking, malware, viruses, illegitimate credentials, phishing, brute force attacks, SQL exploits, or any other method of detrimentally intercepting, interrupting, or damaging any information or functionality related to the Site. You also agree not to transfer access to your Account (as defined below) or any other rights granted to you by these Terms.
Use of the internet is known to not be one-hundred percent secure. You agree that TeaToken is not responsible whatsoever for any damages caused by the interception, loss or alteration to any information sent over the internet. While TeaToken will take reasonable steps to ensure the security and privacy of any information transmitted during your use of our Services, in no event will any such information be considered "confidential" or will its disclosure to a third party, accidental or otherwise, cause liability against TeaToken, even if it occurs as a result of our negligence.
TeaToken takes every reasonable precaution to prevent and mitigate attacks. However, these problems still may occur from time to time for reasons that are out of our control. If TeaToken believes a Token active on the Platform has been compromised or is under attack, TeaToken reserves the right to immediately stop all Services related to such Token. If it is determined that such an attack caused an associated Token to rapidly lose value or otherwise cause or threaten to cause damage to the Platform, the Site, or other users, TeaToken may immediately discontinue all activity regarding such Token entirely at its discretion. Resolution concerning deposits, withdrawals, Account balances, Services or other disputes related to an attacked Token will be determined on a case-by-case basis. TeaToken makes no representation and does not warrant the safety of the Platform and is not liable for any lost value or stolen property, regardless of whether TeaToken was negligent in providing appropriate security.
In no way should our providing of Services be considered legal, financial, investing advice or any other kind of specialized or expert advice on which the User might detrimentally depend, causing liability against TeaToken. In using the Platform, you represent and warrant that you have sought any legal, financial, investment or otherwise specialized advice from an expert qualified to provide such counsel, or else you have the sufficient knowledge and sophistication to evaluate the risks and merits associated with Blockchain and/or Token management and offerings and to competently use our Services. We give no warranty regarding the suitability of any Tokens or other assets acquired using our Platform and assume no fiduciary duties to you.
The User represents and warrants you understand that any recommendations or commentary made by TeaToken or its employees or other users should be considered generalized in nature, and you should use your own judgment or seek the advice of an expert before taking any action regardless of such statement. We give no assurance as to the accuracy or completeness of any such statement.
The User can transfer ETH to our Platform to purchase tokens listed on the Site. Your funds will appear in your Account depending on the processing time of the transaction, which is out of TeaToken's control. Tokens can only be purchased during the official token sale by accepting the respective Terms of Token Sale.
Tokens purchased by the User will be issued according to the respective Terms of Token Sale. Once issued by the seller of the tokens, TeaToken will distribute your tokens through your Ethereum wallet via smart contract. You shall be responsible for implementing reasonable measures for securing the wallet, vault or other storage mechanism your decide to use to receive and hold Tokens outside of your Account, including any requisite private key(s) or other credentials necessary to access such storage mechanism(s). If your private key(s) or other access credentials are lost, you may lose access to the purchased tokens. TeaToken shall not be responsible for any such losses.
We grant you a limited, nonexclusive, nontransferable license ("License") to access and use our Platform, Site and Services. This License is subject to these Terms. Any other use of the Services not expressly permitted by these Terms is prohibited. All other rights in the Platform are reserved by TeaToken and our licensors, including that to any content or functionality as presented on the Site or the Platform. "TeaToken," "TeaToken.com", all logos related to Services or displayed on the Site are trademarks or registered marks of TeaToken or its affiliates. You will not redistribute, claim ownership, license, deconstruct, reverse engineer, alter, incorporate into any other works or websites, or otherwise exploit any such content or functionality without prior express written consent of TeaToken.
We may terminate or suspend your License to our Services without prior notice or liability for any reason whatsoever, including (but not limited to) if you breach the Terms. Nothing in these terms or in any other communication or action by TeaToken or our employees, agents or representatives should be taken as a waiver of any legal remedies available for any event causing termination.
All provisions of the Terms which by their nature should survive termination shall survive termination, including (but not limited to) ownership provisions, disclaimers or limitations of obligations or liability, and indemnity.
TeaToken or other users may provide links to third-party web sites or services that are not owned or controlled by TeaToken. TeaToken has no control over, and assumes no responsibility for, the content, privacy policies, or practices of any third party web sites or services. You further acknowledge and agree that TeaToken shall not be responsible or liable, directly or indirectly, for any damage or loss caused or alleged to be caused by or in connection with use of or detrimental reliance on any information, content, goods or services available on or through any such web sites or services. TeaToken is not liable for any loss or damage incurred as a result of interacting with any third party content on our Site.
You agree that any materials, information or communications transmitted between the User and TeaToken in any form, or between the User and any other TeaToken user via our Platform, are non-confidential and will become the sole, exclusive property of TeaToken. TeaToken will own all intellectual property rights to such communications or materials, and can use or disseminate them in a completely unrestricted fashion for any legal purpose, commercial or otherwise, without notifying or compensating you. You hereby waive any right to litigation or recovery for perceived damages caused by the use of this information as is permissible by law.
You agree to indemnify, exculpate and hold TeaToken, its representatives, affiliates, employees and service providers harmless from any claim or demand permissible by law arising out of or related to the use of these Services, including any breach by you of these Terms or violation of any law, rule, or rights of a third party. You agree to pay for any legal fees or other costs that incurred TeaToken or any other indemnified parties as a result of your actions.
TeaToken does not guarantee any level of performance or the continued, uninterrupted availability of our Services. We do not guarantee the accuracy of any information provided on the Site. We hereby disclaim all warrants and guarantees that not expressly made in these Terms.
The validity, interpretation, construction and performance of these Terms, and all acts and transactions pursuant hereto and the rights and obligations of the parties hereto shall be governed, construed and interpreted in accordance with the laws of the United States, without giving effect to principles of conflicts of law.
Except for any disputes, claims, suits, actions, causes of action, demands or proceedings (collectively, "Disputes") in which either Party seeks to bring an individual action in small claims tribunals or seeks injunctive or other equitable relief for the alleged unlawful use of intellectual property, including, without limitation, copyrights, trademarks, trade names, logos, trade secrets or patents, you and the Company (i) waive your and the Company's respective rights to have any and all Disputes arising from or related to these Terms resolved in a court, and (ii) waive your and the Company's respective rights to a jury trial. Instead, you and the Company will arbitrate Disputes through binding arbitration (which is the referral of a Dispute to one or more persons charged with reviewing the Dispute and making a final and binding determination to resolve it instead of having the Dispute decided by a judge or jury in court).
Any Dispute arising out of or related to this Agreement is personal to you and the Company and will be resolved solely through individual arbitration and will not be brought as a class arbitration, class action or any other type of representative proceeding. There will be no class arbitration or arbitration in which an individual attempts to resolve a Dispute as a representative of another individual or group of individuals. Further, a Dispute cannot be brought as a class or other type of representative action, whether within or outside of arbitration, or on behalf of any other individual or group of individuals. Any Dispute shall be referred to and finally resolved by arbitration administered by the Singapore International Arbitration Centre ("SIAC") in accordance with the Arbitration Rules of the Singapore International Arbitration Centre ("SIAC Rules") for the time being in force, which rules are deemed to be incorporated by reference in this clause. The seat of the arbitration shall be Singapore. The Tribunal shall consist of three (3) arbitrator(s). The language of the arbitration shall be English.
Any portion of these Terms that reasonably should survive the termination of your License or any other agreement is hereby agreed to do so. If any provision of these terms is deemed illegal, invalid or otherwise invalid for any reason, then that provision will be severed and the rest of these Terms will remain intact and enforceable.
Our failure to exercise or enforce any rights or provisions of these Terms does not constitute a waiver of those rights or provisions. These Terms represent the entire and complete agreement between the User and TeaToken, including any future modification of these Terms, superseding any prior agreements or communications between you and us. Any ambiguities in these Terms shall be construed in the light most favorable to TeaToken.
TeaToken' performance under these Terms shall be excused if the failure of such performance is caused by forces beyond its reasonable control. This includes (but is not limited to) acts of God, acts of any government, war or civil unrest, severe weather, fire, natural disasters, political embargos, terrorism, power or equipment failure, industrial or labor disputes or controversies, acts of any third party, or blockchain failures.
If you have any questions about these Terms, please contact us at info@teatoken.io.


what this does
-
register the link
-
link register records it into an array
-
when you click the link it finds the link in th array, and does the callback
-
the callback calls the function to load in the page
-
also brings in the js
-
can be activated by hash, and by load & refresh


--- layout: page title: Error 404 display_title: false main_image_path: /assets/images/pants-404-vs-4-pink-1000w.jpg main_image_caption: _options: layout: hidden: true permalink: hidden: true image_path: uploads_dir: 'assets/images/:year' width: 1200 height: 1200 resize_style: contain mime_type: 'image/jpeg,image/png,image/gif' main_image_path: uploads_dir: 'assets/images/:year' width: 1200 height: 1200 resize_style: contain mime_type: 'image/jpeg,image/png,image/gif' content: uploads_dir: 'assets/:year' _comments: title: Page title main_image_path: Image used to represent your page ---
Error 4÷4


LUCLI(1) LUCLI(1) NAME lucli - command line interface to the Lucene full-text indexing library SYNOPSIS lucli DESCRIPTION lucli is a program that allows you to work directly with Lucene indexes. Once inside lucli you can use the following commands: count Return the number of hits for a search. Example: count foo explain Explanation that describes how the document scored against query. Example: explain foo help Display help about commands index Choose a different lucene index. Example index my_index info Display info about the current Lucene index. Example: info optimize Optimize the current index quit Quit/exit the program search Search the current index. Example: search foo terms Show the first 100 terms in this index. Supply a field name to only show terms in a specific field. Example: terms tokens Does a search and shows the top 10 tokens for each document. Ver‐ bose! Example: tokens foo AUTHOR lucli was written as a part of Lucene, the Java full-text indexing library. See http://lucene.apache.org for more information. This manual page was written by Jan-Pascal van Best <janpas‐<EMAIL_ADDRESS>for the Debian project (but may be used by others). September 4, 2007 LUCLI(1)


Approximate Weight of Trash Collected
Approximate Area Cleaned
Number of Volunteers
Total Number of Trash Bags Filled (optional)
<%= item.name %>


{% if include.alt_title %}{{include.alt_title}}{% else %}Fight corruption in politics{% endif %}
{% if include.alt_title %}{{include.alt_body}}{% else %}Help send reformers to Congress to fight big money from special interests! Take back our Republic.{% endif %}


This is an example of using WebRTC:
"video conference in a browser".
Supported browsers:
Chrome (ver. >= 23)
Firefox (ver. >= 22)
Video and audio Real-Time Communication for browsers. Available in Chrome's stable version, Firefox's nightly version.
Handles API to WebRTC in a browser, manages websockets connection to server, does some browser side work.
Nice and simple web frontend.
Works on server. Handles browsers' registration, video rooms, WebRTC signaling, web chat, websockets transport.
Nice high-performance web server written in Erlang. Handles websockets connections and some HTTP requests.
Transport for signaling messages between browsers and server. Transport for clients' chat messages.