Type of INDC: The Federated States of Micronesia (FSM) commits to reduce GHGs emission in percentage terms on a base year target.
Unconditional: The FSM commits to unconditionally reduce by 2025 a 28% its GHGs emissions below emissions in year 2000.
Conditional: Similarly, subject to the availability of additional financial, technical and capacity building support from the international community, the FSM could do by 2025 an additional reduction up to 35% below emissions in the 2000 base year.
Type: Sectoral Targets
Reference year or period:
Target year: 2025
Scope and coverage:
Planning processes
This INDC was developed through a stakeholder consultation process involving representatives of the National Government, the four FSM State Governments, Agencies and representatives from the private sector, civil society and non- government organizations. It builds upon existing renewable energy and transport targets and policies.
Assumptions and methodological approaches
| GWPs used | Global Warming Potential on a 100 year timescale in accordance with the IPCCs 4th Assessment Report. |
| Inventory methodology | The FSM GHG inventory for year 2000 contained in the Second National Communication utilized the revised 1996 IPCC Guidelines. |
| Land sector emissions | N/A |
| International market mechanisms | FSM does not intend to use international market mechanisms. |
| Baseline | BAU scenarios for the electricity generation and transport sub-sectors were developed using the tool ‘Long-range Energy Alternative Planning System’ (LEAP). The following data was used in the LEAP model:
Current electricity rate: International Renewable Energy Agency (IRENA) Report (2011) Historical electricity use:
|
| Mitigation effects | Individual assumptions were made for the mitigation scenarios. These can be found in the technical report ‘Electricity Sector Analysis for Federated States of Micronesia’s Intended Nationally Determined Contribution’ prepared by NREL. |
FSM’s contribution to climate change has always been marginal. Decision 1/CP.20 paragraph 11 provides the flexibility to SIDS to communicate information on strategies, plans and actions for low greenhouse gas emission development reflecting their special circumstances in the context of intended nationally determined contributions. In this context, the present INDC by FSM is ambitious due to the percentage type considered.
Moreover, national efforts to implement INDC in FSM imply that resources to be allocated for development priorities will be arbitrated to take into account the requirements of the implementation of the Paris Agreement.
By presenting an ambitious INDC in the context of the Paris’ agreement, FSM would like to stress that the very survival of many SIDS is at stake without ambitious global emissions reductions that will ensure the stabilisation of the greenhouse gas emission, ensuring we are on track toward limitation of global temperature rise below 1.5 degree Celsius by 2100.
As for all SIDS, adaptation constitutes a priority for FSM. It is therefore important that the Paris Agreement deals effectively with the adaptation needs in a post 2020 world.
FSM does not see this INDC as the vehicle to address its adaptation needs in the post 2020 context, even if these need careful consideration and assessment. Such assessments are being made in the context of the Nation Wide Integrated Disaster Risk Management and Climate Change Policy 2013 and the FSM Climate Change Act 2014, as well as the joint state action plans for disaster risk management and climate change adaptation. All necessary efforts are being made to engage the country in the formulation and implementation of transformational adaptation investment plans to protect the country against climate change, through various sources of funding including from the UNFCCC financial mechanisms, the Green Climate Fund in particular.
Financial needs:
Much will be needed for the implementation of FSM’s INDC. An assessment of the implementation options is needed as soon as possible to ensure implementation no later than 2018. Potential sources will include the financial mechanisms of the Convention, other non-Convention financial and investments sources, as well as international, national and other financial sources. All these will be facilitated and enabled by public policy and regulatory frameworks.
Technical requirements:
There is a need to design a national inventory system and to develop a framework for domestic Monitoring Reporting and Verification (MRV) of GHG emissions. There is a further need to access expertise and develop capacities to conduct such a process at the national and state levels.
Capacity building needs:
There is a need to enhance the local capacity to plan, design, implement, manage, operate and maintain installed energy technologies. Similarly, human, technical and institutional capacity development is required in the following areas: GHG inventory, baseline scenario development, emissions projection, vulnerability assessment, adaptation needs evaluation and prioritisation, climate finance access, mobilisation and disbursement.
Technology needs:
Specifically to implement the INDC in the energy sector, locally appropriate technology and equipment (resilient to the elements and extreme events) needs to be assessed and procured.
FSM’s INDC has been developed with the joint collaboration of the National Renewable Energy Laboratory (NREL) of the United States Department of Energy and Climate Analytics as implementing agency of the INDC Global Support Project by Gesellschaft für Internationale Zusammenarbeit (GIZ) GmbH, financed by the Government of Germany Ministry for the Environment, Nature Conservation, Building and Nuclear Safety.


--- short: x-virtuosoextractor type: other color: grey title: Virtuoso extractor description: Instructs Virtuoso to dump a graph. ---
Special purpose component, allows the user to instruct OpenLink Virtuoso triplestore to dump a named graph to the remote file system. Uses Virtuoso Bulk Loader functionality.
1111
)The {{page.title}} component instructs a remote instance of OpenLink Virtuoso to dump a named graph using the Virtuoso Bulk Loader. It is recommended to use it together with Extract from FTP or HTTP get to download larger RDF files (approx. > 5M triples) from Virtuoso, and Decompress archive to decompress them, as they get dumped Gzipped.


--- layout: post title: "No Title" ---
We visited Underwater World in Mooloolaba. When I snapped this there was a man toting a Nikon D3 with a massive lens shooting about 3 frames a second, pausing, reviewing and repeating. We continued looking around and when we came back 15 minutes later, he was still there.


El Paraíso Restaurant has many catering options, the perfect solution for your busy schedule. Whether you're feeding your family or any large group, we've got you covered. All of our options come with our guarantee of quality or your money back.
For all of your regular orders, please see our menu here and contact us. When you drop by, we will have your food ready!


Demo: Accessible accordion using ARIA and Vanilla JavaScript
An accordion animated multi-selectable…
Yes, it rocks.
… not opened by default
Yes, it rocks too.
Another accordion not animated…
Yes, it rocks, called with a different configuration.
… and not multi-selectable
Yes, it rocks anyway.
Sub-accordion 1
Stop please, too cool.
Sub-accordion 2
Even cooler.


2
domestic | general | citation, commencement and interpretation | 2010
regulation
mandatory
Regulation 2 sets out the defined terms within the regulations. It is
not reproduced in section 0; instead the terms have been
incorporated in the list of defined terms which form Appendix A.
0.2.1 Explanation of Regulation 1
Regulation 1 is not reproduced above but contains the citation and
commencement of the building regulations. They apply to
buildings
and
exempted by regulation 3, schedule 1. The full text is:
Regulation 1
These regulations may be cited as the Building (Scotland) Regulations
2004 and shall come into force on 1 May 2005.
permanent. This is very wide, but there are exceptions in
the Act
for:
•
any
public road
(including any bridge on which the
road
is carried);
•
any
private road
(bridges on
private roads
are not excluded in
the Act
);
•
any sewer or water main vested in Scottish Water;
•
any aerodrome runway;
•
any railway line;
•
any large raised reservoir within the meaning of the Reservoirs Act 1975;
•
any wires and cables, their supports above ground and other apparatus
used for telephonic or telegraphic communications.
The term
building
is, subject to context, taken to include a prospective
building
, a part of a
building
and, for extensions, alterations and
conversions
,
it can mean the extension alone or the part subject to alteration or
conversion
.
Works
in relation to a
building
is defined in
the Act
as including
Works
therefore includes all
construction
, demolition and
conversion work
,
the provision of services fittings and equipment, and any
work
carried out in
relation to the
site
.
where an application for warrant is made on or after 1 May 2005. In the case
application for warrant is made on or after 1 May 2009. However full
exemption from the
building
standards system is provided for defence and
national security
buildings
in legislation under The Building (Scotland) Act
2003 (Exemptions for Defence and National Security) Order 2009, SI 2009
No.822 (S.6).
The Building (Scotland) Act 2003 (Commencement No.2 and Transitional
to 1 May 2009 to continue with immunity from
building
regulations. In
addition,
work
carried out pursuant to a contract entered into prior to 1 May
2009 will continue with immunity on the basis that
work
commenced before 1
November 2009. In both cases,
work
must be complete before 1 May 2012.
0.2.1
—
0.2.1
domestic | general | citation, commencement and interpretation | 2010
commencing before 1 May 2005 are subject to previous building standards
and procedures regulations, in particular the time by when these
works
must
be completed. Previously exempt
works
, in particular any no longer exempt,
must have been completed by 2 September 2005, otherwise the exemption
falls and a warrant for any outstanding
work
may be required.
On completion of the
works
, before the period specified in the building
warrant expires, a completion certificate must be submitted. If a completion
certificate is submitted for
work
done without a warrant, the regulations that
are applicable are those in force at the time of submission of the certificate,
which may well be more onerous that those which would have applied when
the
work
started. Fuller details of the arrangements for submitting warrant
applications and completion certificates will be given in the guidance on the
procedure regulations.
The building regulations also incorporate requirements previously set in
separate Building Operations Regulations (regulations 13-15). These cover
the provision of protective
works
, clearing of footpaths and securing of
unoccupied
buildings
.
The following is a list of all amendments made to the Building (Scotland)
Regulations 2004, together with the date they came into force and a
summary of the major changes.
The Building (Scotland) Amendment Regulations 2006 (1 May 2007)
•
New regulation 17 inserted to implement the terms of Article 9 of EPBD
regarding the inspection of air conditioning systems.
•
Schedule 3 - changes to
building
types 1,2,5,6 and 19.
•
Schedule 5 - minor changes to functional standards. New functional
standards 6.9 and 6.10.
The Building (Scotland) Amendment Regulations 2007 (28 March 2007)
•
Replacement Schedule 2 for that contained in 2006 amendments.
•
Schedule 5 - minor changes to functional standards 6.9 and 6.10.
The Building (Scotland) Amendment Regulations 2008 (4 January 2009)
•
Minor changes to reflect requirements of energy performance certificates.
The Building (Scotland) Amendment Regulations 2009 (1 May 2009)
•
Schedule 1 - change to paved areas or hardstanding exempt from
regulations 8-13.
•
Schedule 3 - amended to include certain Crown
buildings.
The Building (Scotland) Amendment Regulations 2010 (1 October 2010)
•
Schedule 3 - rewording of
building
type 2A.
•
Schedule 5 - minor changes to several functional standards. Re-write of
functional standard 5.1 and new functional standard 5.2.
0.2.1
—
0.2.1
•
Schedule 1 - changes to
building
types 1 and 20.
domestic | general | citation, commencement and interpretation | 2010
0.2.2 Explanation of Regulation 2
Regulation 2 sets out the defined terms within the regulations. It is not
reproduced in section 0, instead the terms have been incorporated in the list
of defined terms which form Appendix A. The Appendix also includes
definitions from the Building (Scotland) Act 2003 and those used in these
Technical Handbooks.
All of the terms defined above, including those from the regulations, are in
italics throughout the Handbooks.
In the determination of the description of a
building
, any use which is ancillary
to another use or which is of a minor nature should be disregarded and the
building
taken to be that of the principal description. Minor uses within the
office
for use by up to two people. Notwithstanding the above, parts of a
building
may be considered to be of a separate description where the context
requires (for example a caretakers
flat
should be taken separately from any
other part of the
building
in which it is located).
accommodation, of a floor area not exceeding in the aggregate 50 square
in a professional or business capacity. A
dwelling
may provide bed and
breakfast facilities provided this does not exceed two double bedrooms and
is not in use for more than half of the year.
Where further guidance on
building
types is needed to define the proposals
for particular
buildings
, it is included in the relevant section.
0.2.2
—
0.2.2


no contacts start adding them now Create a new contact Import your contacts from your SIM card or from Facebook Search Favorites #anchor#
#type# #value# #carrier# Birthday #bday# #type# #value# Social Network Message Wall Post View Facebook profile #action# #type# Address #streetAddress# #postalCode# #locality# #countryName# #note# Add as favorite
Order by last name Transfer Contacts Import Contacts Export Contacts Facebook Sync friends Update imported friends Contacts Management Set ICE Contacts Bulk delete
Add two contacts for making “In Case of Emergency” calls. ICE Contact 1 Select a contact ICE Contact 2 Select a contact


18. GeoMesa Native API¶
The GeoMesa Native API (geomesa-native-api
in the source distribution) is for developers who prefer not to use GeoTools interfaces and just want to geo index their
data. It exposes a simple interface for persisting and querying GeoMesa as well as a simple integration point with
Geoserver in cases where OGC access is still desired.
18.1. Usage¶
To interact with the GeoMesa Native API, instantiate an instance of a GeoMesaIndex<T>
with your payload type T
.
GeoMesaIndex<DomainObject> index =
AccumuloGeoMesaIndex.build(
"hello",
"zoo1:2181",
"mycloud",
"myuser", "mypass",
true,
new DomainObjectValueSerializer(),
new DefaultSimpleFeatureView<DomainObject>("foo"));
In the code snippet above, we are instantiating an AccumuloGeoMesaIndex
with a type parameter of DomainObject
, the
payload object type that is specific to each usage of the native API. We have provided a DomainObjectValueSerializer
an implementation of ValueSerializer
which tells the native API how to convert the domain object into a byte array
payload. We have also provided a DefaultSimpleFeatureView
which maintains integration with the Geotools infrastructure.
The DefaultSimpleFeatureView
will create a SimpleFeatureType
that contains the geometry, date, and identifier of the
DomainObject
and enable querying based on these attributes. If you want to enable querying on more attributes from
your domain object, you should create a class that extends SimpleFeatureView
and converts the domain object into a
rich SimpleFeature
. You can then leverage GeoMesa’s secondary indexing optimizations on first class attributes.
Persisting data to a GeoMesaIndex
requires utilizing the various insert
methods. The following code snippet demonstrates
how you can put domain objects into the index.
final GeometryFactory gf = JTSFactoryFinder.getGeometryFactory();
DomainObject one = new DomainObject();
DomainObject two = new DomainObject();
index.insert(
one,
gf.createPoint(new Coordinate(-78.0, 38.0)),
date("2016-01-01T12:15:00.000Z"));
index.insert(
two,
gf.createPoint(new Coordinate(-78.0, 40.0)),
date("2016-02-01T12:15:00.000Z"));
The code above will compute an identifier for each of the domain objects. If you want to control the identifiers,
use the insert
methods with id
in the signature. If you do not intend to query GeoMesa using the specific identifiers of
your domain object, prefer the method that generates an identifier for you. The reason is that the identifier chosen by
GeoMesa optimizes the locality properties of the identifier and thus the caching within the underlying database.
- To query data stored using the GeoMesa Native API, build up a
GeoMesaQuery
and pass it to theGeoMesaIndex
. - For example, the following code snippet queries GeoMesa on space and time.
GeoMesaQuery q =
GeoMesaQuery.GeoMesaQueryBuilder.builder()
.within(-79.0, 37.0, -77.0, 39.0)
.during(date("2016-01-01T00:00:00.000Z"), date("2016-03-01T00:00:00.000Z"))
.build();
Iterable<DomainObject> results = index.query(q);
If you have used a custom SimpleFeatureView
, you can query on the attributes you’ve lifted into the SimpleFeatureType
.
For instance, if you have lifted an attribute called age
into the SimpleFeatureType
, you can query on it as follows and
GeoMesa will push the age
predicate down for processing in the database.
FilterFactory ff = CommonFactoryFinder.getFilterFactory2();
GeoMesaQuery q =
GeoMesaQuery.GeoMesaQueryBuilder.builder()
.within(-79.0, 37.0, -77.0, 39.0)
.during(date("2016-01-01T00:00:00.000Z"), date("2016-03-01T00:00:00.000Z"))
.filter(ff.greaterThan(ff.property("age"), 30)
.build();
Iterable<DomainObject> results = index.query(q);


Constructor
new SegmentEngine(optionsopt)
Parameters:
| Name | Type | Attributes | Default | Description | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
options |
Object |
<optional> |
{} | Default options Properties
|
- Source:
Example
import * as audio from 'waves-audio';
const scheduler = audio.getScheduler();
const segmentEngine = new audio.SegmentEngine();
scheduler.add(segmentEngine);
Extends
Members
abortTime :Number
Fade-out time (when aborted)
Type:
- Number
- Default Value:
- 0.005
- Source:
attackAbs :Number
Absolute attack time in sec
Type:
- Number
- Default Value:
- 0.005
- Source:
attackRel :Number
Attack time relative to segment duration
Type:
- Number
- Default Value:
- 0
- Source:
buffer :AudioBuffer
Audio buffer
Type:
- AudioBuffer
- Default Value:
- null
- Source:
bufferDuration :Number
Get buffer duration (excluding wrapAroundExtension)
Type:
- Number
- Default Value:
- 0
- Source:
cyclic :Bool
Whether the audio buffer and segment indices are considered as cyclic
Type:
- Bool
- Default Value:
- false
- Source:
delay :Number
Time by which all segments are delayed (especially to realize segment offsets)
Type:
- Number
- Default Value:
- 0.005
- Source:
durationAbs :Number
Absolute segment duration in sec
Type:
- Number
- Default Value:
- 0
- Source:
durationArray :Number
Array of segment durations in sec
Type:
- Number
- Default Value:
- [0.0]
- Source:
durationRel :Number
Segment duration relative to given segment duration or inter-segment distance
Type:
- Number
- Default Value:
- 1
- Source:
gain :Number
Linear gain factor
Type:
- Number
- Default Value:
- 1
- Source:
monophonic :Number
Whether the last segment is aborted when triggering the next
Type:
- Number
- Default Value:
- false
- Source:
offsetAbs :Number
Absolute segment offset in sec
Type:
- Number
- Default Value:
- -0.005
- Source:
offsetArray :Array
Array of segment offsets in sec
offset > 0: the segment's reference position is after the given segment position offset < 0: the given segment position is the segment's reference position and the duration has to be corrected by the offset
Type:
- Array
- Default Value:
- [0.0]
- Source:
offsetRel :Number
Segment offset relative to segment duration
Type:
- Number
- Default Value:
- 0
- Source:
periodAbs :Number
Absolute segment period in sec
Type:
- Number
- Default Value:
- 0
- Source:
periodMin :Number
Minimum segment period
Type:
- Number
- Default Value:
- 0.001
- Source:
periodRel :Number
Segment period relative to inter-segment distance
Type:
- Number
- Default Value:
- 1
- Source:
periodVar :Number
Amout of random segment period variation relative to segment period
Type:
- Number
- Default Value:
- 0
- Source:
positionArray :Number
Array of segment positions (onset times in audio buffer) in sec
Type:
- Number
- Default Value:
- [0.0]
- Source:
positionVar :Number
Amout of random segment position variation in sec
Type:
- Number
- Default Value:
- 0
- Source:
releaseAbs :Number
Absolute release time in sec
Type:
- Number
- Default Value:
- 0.005
- Source:
releaseRel :Number
Release time relative to segment duration
Type:
- Number
- Default Value:
- 0
- Source:
resampling :Number
Segment resampling in cent
Type:
- Number
- Default Value:
- 0
- Source:
resamplingVar :Number
Amout of random resampling variation in cent
Type:
- Number
- Default Value:
- 0
- Source:
segmentIndex :Number
Index of the segment to synthesize (i.e. of this.positionArray/durationArray/offsetArray)
Type:
- Number
- Default Value:
- 0
- Source:
wrapAroundExtension :Number
Portion at the end of the audio buffer that has been copied from the beginning to assure cyclic behavior
Type:
- Number
- Default Value:
- 0
- Source:
Methods
abort(time)
Abort the current segment at given time, fade out duration
Parameters:
| Name | Type | Description |
|---|---|---|
time |
Number | abort time |
- Source:
connect(target)
Connect to an audio node (e.g. audioContext.destination)
Parameters:
| Name | Type | Description |
|---|---|---|
target |
AudioNode | Target audio node |
- Inherited From:
- Source:
disconnect(target)
Disconnect from an audio node (e.g. audioContext.destination). If undefined disconnect from all target nodes.
Parameters:
| Name | Type | Description |
|---|---|---|
target |
AudioNode | Target audio node. |
- Inherited From:
- Source:
trigger(time) → {Number}
Trigger a segment. This function can be called at any time (whether the engine is scheduled/transported or not) to generate a single segment according to the current segment parameters.
Parameters:
| Name | Type | Description |
|---|---|---|
time |
Number | segment synthesis audio time |
- Source:
Returns:
period to next segment
- Type
- Number


| Title | Author | Publisher | Edition | Library | Date of Issue | Date of Submission | Your Rating |
|---|---|---|---|---|---|---|---|
| Malgudi Days | R.K. Narayan | Unknown | 3 | Harekrishna Library | 2016-01-21 | 2016-02-21 | 3.5 |
| Title | Author | Publisher | Edition | Library | Call No | Category | Rating |
|---|---|---|---|---|---|---|---|
| Swami & His Friends | R.K. Narayan | Unknown | 5 | Harekrishna Library | XC/101 | Fiction | 5 |
| Title | Author | Publisher | Edition | Library | Date of Issue | Date of Recieve | Fine |
|---|---|---|---|---|---|---|---|
| Malgudi Days | R.K. Narayan | Unknown | 3 | Harekrishna Library | 2016-01-21 | 2016-02-21 | 1.25 |
| Member ID | Library | Address | Contact No | Book Count | Number of Issue | Last Issued on | Date of Approval | Action |
|---|---|---|---|---|---|---|---|---|
| 1059 | Haripada Library | Kolkata |<PHONE_NUMBER> | 5 | 25 | 2016-08-19 | 2016-04-03 | |
| ED/201 | Shyamapada Library | Kolkata |<PHONE_NUMBER> | 5 | 25 | 2016-08-19 | 2016-04-03 |
| Member ID | Library | Address | Contact No | Book Count | Number of Issue | Last Issued on | Date of Approval | Status |
|---|---|---|---|---|---|---|---|---|
| 1059 | Haripada Library | Kolkata |<PHONE_NUMBER> | 5 | 25 | 2016-08-19 | 2016-04-03 | Pending |
| ED/201 | Shyamapada Library | Kolkata |<PHONE_NUMBER> | 5 | 25 | 2016-08-19 | 2016-04-03 | Removed |
| Request Token | Image | Library | Address | Contact No | Date of Request | Action |
|---|---|---|---|---|---|---|
| EC/20X/11 | Haripada Library | Barasat |<PHONE_NUMBER> | 2016-04-03 | ||
| ED/211 | Harekrishna Library | Barasat |<PHONE_NUMBER> | 2016-04-03 |


---
layout: default
---
Product Manager
- Love people, product, processes, business development, data & UX.
- Learning python and refreshing my stats to be more data minded.
Musician
- I’m a musician who produces music using guitars and Ableton Live.
- Find me on Spotify or SoundCloud.
Human
- Yoga, meditation, swimming and nature keep me grounded.
- Podcasts, books and travelling is how I learn.
Learner
- Journalling and hosting meetups allows me to explore my thoughts.
- Inequality, decentralisation & undiagnosed pain keep me up at night.


Laptops
Desktops
Accessories
Workstations
services
Copy Source Code
Laptops
Desktops
Accessories
Workstations
services
Close
Copy


Man caught trying to enter Parliament building, detained
He was detained by the security personnel and handed over to Delhi Police.
by Puneet Kumar SharmaA man was caught trying to enter the parliament building while the Winter Session was underway on Monday. He was detained by the security personnel and handed over to Delhi Police.
The police are investigating the matter.
The man's identity or his intention to enter the Parliament building are unknown at the time.
The attempted intrusion comes in close to the 18th anniversary of the Parliament terror attack, which took place on December 13, 2001. Five terrorists had opened fire at the security personnel inside the Parliament premises. Fourteen people, including the five terrorists, were killed in the incident.


© Copyright 1986-2008 by The University of Washington. Written by Joseph Felsenstein. Permission is granted to copy this document provided that no fee is charged for it and that this copyright notice is not removed.
Consense reads a file of computer-readable trees and prints out (and may also write out onto a file) a consensus tree. At the moment it carries out a family of consensus tree methods called the Ml methods (Margush and McMorris, 1981). These include strict consensus and majority rule consensus. Basically the consensus tree consists of monophyletic groups that occur as often as possible in the data. If a group occurs in more than a fraction l of all the input trees it will definitely appear in the consensus tree.
The tree printed out has at each fork a number indicating how many times the group which consists of the species to the right of (descended from) the fork occurred. Thus if we read in 15 trees and find that a fork has the number 15, that group occurred in all of the trees. The strict consensus tree consists of all groups that occurred 100% of the time, the rest of the resolution being ignored. The tree printed out here includes groups down to 50%, and below it until the tree is fully resolved.
The majority rule consensus tree consists of all groups that occur more than 50% of the time. Any other percentage level between 50% and 100% can also be used, and that is why the program in effect carries out a family of methods. You have to decide on the percentage level, figure out for yourself what number of occurrences that would be (e.g. 15 in the above case for 100%), and resolutely ignore any group below that number. Do not use numbers at or below 50%, because some groups occurring (say) 35% of the time will not be shown on the tree. The collection of all groups that occur 35% or more of the time may include two groups that are mutually self contradictory and cannot appear in the same tree. In this program, as the default method I have included groups that occur less than 50% of the time, working downwards in their frequency of occurrence, as long as they continue to resolve the tree and do not contradict more frequent groups. In this respect the method is similar to the Nelson consensus method (Nelson, 1979) as explicated by Page (1989) although it is not identical to it.
The program can also carry out Strict consensus, Majority Rule consensus without the extension which adds groups until the tree is fully resolved, and other members of the Ml family, where the user supplied the fraction of times the group must appear in the input trees to be included in the consensus tree. For the moment the program cannot carry out any other consensus tree method, such as Adams consensus (Adams, 1972, 1986) or methods based on quadruples of species (Estabrook, McMorris, and Meacham, 1985).
Input is a tree file (called intree) which contains a series of trees in the Newick standard form -- the form used when many of the programs in this package write out tree files. Each tree starts on a new line. Each tree can have a weight, which is a real number and is located in comment brackets "[" and "]" just before the final ";" which ends the description of the tree. When the input trees have weights (like [0.01000]) then the total number of trees will be the total of those weights, which is often a number like 1.00. When the a tree doesn't have a weight it will be assigned a weight of 1. This means that when we have tied trees (as from a parsimony program) three alternative tied trees will be counted as if each was 1/3 of a tree.
Note that this program can correctly read trees whether or not they are bifurcating: in fact they can be multifurcating at any level in the tree.
The options are selected from a menu, which looks like this:
Consensus tree program, version 3.69 Settings for this run: C Consensus type (MRe, strict, MR, Ml): Majority rule (extended) O Outgroup root: No, use as outgroup species 1 R Trees to be treated as Rooted: No T Terminal type (IBM PC, ANSI, none): ANSI 1 Print out the sets of species: Yes 2 Print indications of progress of run: Yes 3 Print out tree: Yes 4 Write out trees onto tree file: Yes Are these settings correct? (type Y or the letter for one to change) |
Option C (Consensus method) selects which of four methods the program uses. The program defaults to using the extended Majority Rule method. Each time the C option is chosen the program moves on to another method, the others being in order Strict, Majority Rule, and Ml. Here are descriptions of the methods. In each case the fraction of times a set appears among the input trees is counted by weighting by the weights of the trees (the numbers like [0.6000] that appear at the ends of trees in some cases).
Option R (Rooted) toggles between the default assumption that the input trees are unrooted trees and the selection that specifies that the tree is to be treated as a rooted tree and not re-rooted. Otherwise the tree will be treated as outgroup-rooted and will be re-rooted automatically at the first species encountered on the first tree (or at a species designated by the Outgroup option).
Option O is the usual Outgroup rooting option. It is in effect only if the Rooted option selection is not in effect. The trees will be re-rooted with a species of your choosing. You will be asked for the number of the species that is to be the outgroup. If we want to outgroup-root the tree on the line leading to a species which appears as the third species (counting left-to-right) in the first computer-readable tree in the input file, we would invoke select menu option O and specify species 3.
Output is a list of the species (in the order in which they appear in the first tree, which is the numerical order used in the program), a list of the subsets that appear in the consensus tree, a list of those that appeared in one or another of the individual trees but did not occur frequently enough to get into the consensus tree, followed by a diagram showing the consensus tree. The lists of subsets consists of a row of symbols, each either "." or "*". The species that are in the set are marked by "*". Every ten species there is a blank, to help you keep track of the alignment of columns. The order of symbols corresponds to the order of species in the species list. Thus a set that consisted of the second, seventh, and eighth out of 13 species would be represented by:
.*....**.. ...
Note that if the trees are unrooted the final tree will have one group, consisting of every species except the Outgroup (which by default is the first species encountered on the first tree), which always appears. It will not be listed in either of the lists of sets, but it will be shown in the final tree as occurring all of the time. This is hardly surprising: in telling the program that this species is the outgroup we have specified that the set consisting of all of the others is always a monophyletic set. So this is not to be taken as interesting information, despite its dramatic appearance.
Option 2 in the menu gives you the option of turning off the writing of these sets into the output file. This may be useful if you are primarily interested in getting the tree file.
Option 3 is the usual tree file option. If this is on (it is by default) then the final tree will be written onto an output tree file (whose default name is "outtree").
Note that the lengths on the tree on the output tree file are not branch lengths but the number of times that each group appeared in the input trees. This number is the sum of the weights of the trees in which it appeared, so that if there are 11 trees, ten of them having weight 0.1 and one weight 1.0, a group that appeared in the last tree and in 6 others would be shown as appearing 1.6 times and its branch length will be 1.6. This means that if you take the consensus tree from the output tree file and try to draw it, the branch lengths will be strange. I am often asked how to put the correct branch lengths on these (this is one of our Frequently Asked Questions).
There is no simple answer to this. It depends on what "correct" means. For example, if you have a group of species that shows up in 80% of the trees, and the branch leading to that group has average length 0.1 among that 80%, is the "correct" length 0.1? Or is it (0.80 x 0.1)? There is no simple answer.
However, if you want to take the consensus tree as an estimate of the true tree (rather than as an indicator of the conflicts among trees) you may be able to use the User Tree (option U) mode of the phylogeny program that you used, and use it to put branch lengths on that tree. Thus, if you used Dnaml, you can take the consensus tree, make sure it is an unrooted tree, and feed that to Dnaml using the original data set (before bootstrapping) and Dnaml's option U. As Dnaml wants an unrooted tree, you may have to use Retree to make the tree unrooted (using the W option of Retree and choosing the unrooted option within it). Of course you will also want to change the tree file name from "outree" to "intree".
If you used a phylogeny program that does not infer branch lengths, you might want to use a different one (such as Fitch or Dnaml) to infer the branch lengths, again making sure the tree is unrooted, if the program needs that.
The program uses the consensus tree algorithm originally designed for the bootstrap programs. It is quite fast, and execution time is unlikely to be limiting for you (assembling the input file will be much more of a limiting step). In the future, if possible, more consensus tree methods will be incorporated (although the current methods are the ones needed for the component analysis of bootstrap estimates of phylogenies, and in other respects I also think that the present ones are among the best).
TEST SET OF INPUT TREES
(A,(B,(H,(D,(J,(((G,E),(F,I)),C)))))); (A,(B,(D,((J,H),(((G,E),(F,I)),C))))); (A,(B,(D,(H,(J,(((G,E),(F,I)),C)))))); (A,(B,(E,(G,((F,I),((J,(H,D)),C)))))); (A,(B,(E,(G,((F,I),(((J,H),D),C)))))); (A,(B,(E,((F,I),(G,((J,(H,D)),C)))))); (A,(B,(E,((F,I),(G,(((J,H),D),C)))))); (A,(B,(E,((G,(F,I)),((J,(H,D)),C))))); (A,(B,(E,((G,(F,I)),(((J,H),D),C))))); |
Consensus tree program, version 3.69 Species in order: 1. A 2. B 3. H 4. D 5. J 6. G 7. E 8. F 9. I 10. C Sets included in the consensus tree Set (species in order) How many times out of 9.00 .......**. 9.00 ..******** 9.00 ..****.*** 6.00 ..***..... 6.00 ..***....* 6.00 ..*.*..... 4.00 ..***..*** 2.00 Sets NOT included in consensus tree: Set (species in order) How many times out of 9.00 .....**... 3.00 .....***** 3.00 ..**...... 3.00 .....****. 3.00 ..****...* 2.00 .....*.**. 2.00 ..*.****** 2.00 ....****** 2.00 ...******* 1.00 Extended majority rule consensus tree CONSENSUS TREE: the numbers on the branches indicate the number of times the partition of the species into the two sets which are separated by that branch occurred among the trees, out of 9.00 trees +-----------------------C | +--6.00-| +-------H | | +--4.00-| | +--6.00-| +-------J +--2.00-| | | | +---------------D | | +--6.00-| | +-------F | | +------------------9.00-| | | +-------I +--9.00-| | | | +---------------------------------------G +-------| | | | +-----------------------------------------------E | | | +-------------------------------------------------------B | +---------------------------------------------------------------A remember: this is an unrooted tree! |


public final class ZLib
extends totalcross.lang.Object
zlib is designed to be a free, general-purpose, legally unencumbered - that is, not covered by any patents -- lossless data-compression library for use on virtually any computer hardware and operating system. The zlib data format is itself portable across platforms.
| Modifier and Type | Field and Description |
|---|---|
static int |
BEST_COMPRESSION
Compression level for best compression, which is 9 in a scale from 0 (no compression) to 9 (best compression).
|
static int |
BEST_SPEED
Compression level for fastest compression, which is 1 in a scale from 0 (no compression) to 9 (best compression).
|
static int |
DEFAULT_COMPRESSION
Default compression level.
|
static int |
DEFAULT_STRATEGY
Default compression strategy.
|
static int |
DEFLATED
Compression method for the deflate algorithm (the only one currently supported).
|
static int |
FILTERED
Compression strategy best used for data consisting mostly of small values with a somewhat random distribution.
|
static int |
HUFFMAN_ONLY
Compression strategy for Huffman coding only.
|
static int |
NO_COMPRESSION
Compression level for no compression, which is 0 in a scale from 0 (no compression) to 9 (best compression)
|
| Modifier and Type | Method and Description |
|---|---|
static int |
deflate(int compressionLevel,
Stream in,
Stream out)
Deprecated.
use #deflate(Stream, Stream, int) instead
|
static int |
deflate(Stream in,
Stream out)
Deflates the given stream 'in' with the specified compression level, writing the result to the given stream 'out'.
|
static int |
deflate(Stream in,
Stream out,
int compressionLevel)
Deflates the given stream 'in' with the specified compression level, writing the result to the given stream 'out'.
|
static int |
deflate(Stream in,
Stream out,
int compressionLevel,
int strategy,
boolean noWrap)
Deflates the given stream 'in' using the specified strategy and compression level, writing the result to the given
stream 'out'.
|
static int |
inflate(Stream in,
Stream out)
Attempts to fully read the given stream 'in', inflating and writing to the given stream 'out'.
|
static int |
inflate(Stream in,
Stream out,
int sizeIn)
Attempts to read the number of bytes specified by 'sizeIn' from the the given stream 'in', inflating and writing
to the given stream 'out'.
|
static int |
inflate(Stream in,
Stream out,
int sizeIn,
boolean noWrap)
Attempts to read the number of bytes specified by 'sizeIn' from the the given stream 'in', inflating and writing
to the given stream 'out'.
|
public static final int NO_COMPRESSION
public static final int BEST_SPEED
public static final int BEST_COMPRESSION
public static final int DEFAULT_COMPRESSION
public static final int DEFAULT_STRATEGY
public static final int DEFLATED
public static final int FILTERED
public static final int HUFFMAN_ONLY
public static int deflate(Stream in, Stream out) throws IOException
in
- Stream to be deflatedout
- Deflated stream.IOException
DEFAULT_COMPRESSION
public static int deflate(Stream in, Stream out, int compressionLevel) throws IOException
in
- Stream to be deflatedout
- Deflated stream.compressionLevel
- Desired compression level, which must be between 0 and 9, or -1 for the default compression levelIOException
NO_COMPRESSION
,
BEST_SPEED
,
BEST_COMPRESSION
@Deprecated public static int deflate(int compressionLevel, Stream in, Stream out) throws IOException
compressionLevel
- Desired compression level, which must be between 0 and 9, or -1 for the default compression levelin
- Stream to be deflatedout
- Deflated stream.IOException
NO_COMPRESSION
,
BEST_SPEED
,
BEST_COMPRESSION
public static int deflate(Stream in, Stream out, int compressionLevel, int strategy, boolean noWrap) throws IOException
in
- Stream to be deflatedout
- Deflated stream.compressionLevel
- compression level, which must be between 0 and 9, or -1 for the default compression levelstrategy
- the compression strategynoWrap
- if true then use GZIP compatible compressionIOException
NO_COMPRESSION
,
BEST_SPEED
,
BEST_COMPRESSION
public static int inflate(Stream in, Stream out) throws IOException, ZipException
in
- Deflated input streamout
- Inflated output streamIOException
ZipException
public static int inflate(Stream in, Stream out, int sizeIn) throws IOException, ZipException
in
- Deflated input streamout
- Inflated output streamsizeIn
- How many bytes to read, or -1 to read until in
's endZipException
IOException
public static int inflate(Stream in, Stream out, int sizeIn, boolean noWrap) throws IOException, ZipException
in
- Deflated input streamout
- Inflated output streamsizeIn
- How many bytes to read, or -1 to read until in
's endnoWrap
- if true then support GZIP compatible compressionZipException
IOException


Measuring AWS Lambda performance
Measuring AWS Lambda execution times can be in three ways: measure total time of synchronous execution on client side when using HTTP trigger, measure function runtime and return time with the result, as seen below, and use measurements provided by cloud service. The first option is far from ideal since measurements include the cost and variability of client-cloud communication. Such a setup is useful only when measuring the effect of using different cloud regions. The second approach does not include overheads of initialization, and we have no way of measuring cold starts.
import datetime
import function
def handler(event, context):
begin = datetime.datetime.now()
ret = function.handler(event)
end = datetime.datetime.now()
return {
"time" : (end - begin) / datetime.timedelta(microseconds=1),
"message": ret
}
This leaves us an only option: rely on the cloud to share with us exact measurements.
On AWS, we can access metrics stored in AWS CloudWatch,
as long as our function has permissions to access CloudWatch metrics. We can
use Python SDK to access metrics with get_metric_data
.
The query requires multiple parameters and some of them are not that obvious. So
we start with listing available metrics:
import boto3
client = boto3.client('cloudwatch','us-east-1')
client.list_metrics()
The returned JSON includes multiple various metrics; here, we show those relevant to AWS Lambda:
{
"Metrics": [
{
"Namespace": "AWS/Lambda",
"MetricName": "Throttles",
"Dimensions": [
{
"Name": "FunctionName",
"Value": "111_dynamic_html_python_128"
}
]
},
{
"Namespace": "AWS/Lambda",
"MetricName": "Errors",
"Dimensions": [
{
"Name": "FunctionName",
"Value": "111_dynamic_html_python_128"
}
]
},
{
"Namespace": "AWS/Lambda",
"MetricName": "Invocations",
"Dimensions": [
{
"Name": "FunctionName",
"Value": "111_dynamic_html_python_128"
}
]
},
{
"Namespace": "AWS/Lambda",
"MetricName": "Duration",
"Dimensions": [
{
"Name": "FunctionName",
"Value": "111_dynamic_html_python_128"
}
]
},
{
"Namespace": "AWS/Lambda",
"MetricName": "ConcurrentExecutions",
"Dimensions": [
{
"Name": "FunctionName",
"Value": "111_dynamic_html_python_128"
}
]
}
],
"ResponseMetadata": {
"RequestId": "4569d7d8-324e-49a1-b7a9-46893833133a",
"HTTPStatusCode": 200,
"HTTPHeaders": {
"x-amzn-requestid": "4569d7d8-324e-49a1-b7a9-46893833133a",
"content-type": "text/xml",
"content-length": "9038",
"vary": "accept-encoding",
"date": "Thu, 09 Jan 2020 17:06:44 GMT"
},
"RetryAttempts": 0
}
}
As we can see, for each function, we can measure the number of invocations, execution times, concurrency and errors. Continuing with Python API, we can run queries such as the one below, computing average duration for all one-hour periods on the 9th of January.
client.get_metric_data(
MetricDataQueries=[{
"Id": "myRequest",
"Label": "myRequestLabel",
"ReturnData": True,
"MetricStat": {
"Period": 3600,
"Unit": "Milliseconds",
"Stat": "Average",
"Metric": {
"Namespace": "AWS/Lambda",
"MetricName": "Duration"
}
}
}],
StartTime=datetime.datetime(2020, 1, 9),
EndTime=datetime.datetime(2020, 1, 10))
The query provides results for each time period:
{
'MetricDataResults': [{
'Id': 'myRequest',
'Label': 'myRequestLabel',
'Timestamps': [
datetime.datetime(2020, 1, 9, 21, 0, tzinfo=tzutc()),
datetime.datetime(2020, 1, 9, 20, 0, tzinfo=tzutc()),
datetime.datetime(2020, 1, 9, 19, 0, tzinfo=tzutc()),
datetime.datetime(2020, 1, 9, 18, 0, tzinfo=tzutc()),
datetime.datetime(2020, 1, 9, 17, 0, tzinfo=tzutc()),
datetime.datetime(2020, 1, 9, 16, 0, tzinfo=tzutc()),
datetime.datetime(2020, 1, 9, 10, 0, tzinfo=tzutc()),
datetime.datetime(2020, 1, 9, 1, 0, tzinfo=tzutc())
],
'Values': [
3529.3, 3583.6459999999997, 87.735,<PHONE_NUMBER>090909,
49.782000000000004, 8.254999999999999, 0.34, 0.27
],
'StatusCode': 'Complete'
}],
'Messages': [],
'ResponseMetadata': {
'RequestId': '48c7aedc-e87d-45bb-9045-adf8156be358',
'HTTPStatusCode': 200,
'HTTPHeaders': {
'x-amzn-requestid': '48c7aedc-e87d-45bb-9045-adf8156be358',
'content-type': 'text/xml',
'content-length': '1240',
'date': 'Fri, 10 Jan 2020 12:19:11 GMT'},
'RetryAttempts': 0
}
}
Although the set of available statistics is quite extensive, including even percentiles to measure tail latency, it is not possible to access raw data since the lowest sampling period is 60 seconds. While it’s definitely useful for large applications where functions could be executed dozens of thousands of times per day, we can’t do detailed experiments and obtain histogram to understand stragglers and outliers.
Fortunately, more detailed data is available in CloudWatch logs. Each function execution is followed by the message summarizing not only compute but also initialization time:
START RequestId: bb6b75bb-e119-464c-8e24-1db141d951fa Version: $LATEST
END RequestId: bb6b75bb-e119-464c-8e24-1db141d951fa
REPORT RequestId: bb6b75bb-e119-464c-8e24-1db141d951fa
Duration: 33.99 ms
Billed Duration: 100 ms
Memory Size: 128 MB
Max Memory Used: 57 MB
Init Duration: 55.74 ms
To obtain that information, we don’t have to query logs since it can be returned with every function call when we provide Tail as log type in function invocation. The return will include a base64-encoded log which can be parased with the following code to obtain exact time measurements in milliseconds precision.
ret = self.client.invoke(
FunctionName=name,
Payload=payload,
LogType='Tail'
)
if 'FunctionError' in ret:
logging.error('Invocation of {} failed!'.format(name))
logging.error('Input: {}'.format(payload.decode('utf-8')))
raise RuntimeError()
log = base64.b64decode(ret['LogResult'])
vals = {}
for line in log.decode('utf-8').split('\t'):
if not line.isspace():
split = line.split(':')
vals[split[0]] = split[1].split()[0]
return vals
{
'START RequestId': '2430372f-9fcb-4b9c-8179-8b4b71c86f28',
'Duration': '18.37',
'Billed Duration': '100',
'Memory Size': '128',
'Max Memory Used': '57',
'Init Duration': '60.74'
}
Query CloudWatch logs
However, the solution presented above works quite well only when we invoke the
function synchronously. If we choose ‘Event’ invoke type, the return value consists
only of return code, 202
in case of a correct enqueue of function invocation to
AWS queue. It’s a useful feature when we want test our function or evaluate performance
by scheduling multiple invocations at the same time. How can we query the function log afterwards?
The only option is to use the AWS CloudWatch. The query language
description with samples is available in AWS docs,
here we focus only on getting REPORT
events that contain information interesting to us.
region = ''
lambda_function = ''
startTime = 0 # seconds from epoch
endTime = 0 # seconds from epoch
client = boto3.client('logs', region)
query = client.start_query(
logGroupName='/aws/lambda/{}'.format(lambda_function),
queryString="filter @message like /REPORT/",
startTime=startTime,
endTime=endTime
)
query_id = query['queryId']
response = None
while response == None or response['status'] == 'Running':
time.sleep(1)
response = client.get_query_results(
queryId=query_id
)
The query result will contain information on results selected
"statistics": {
"recordsMatched": 15.0,
"recordsScanned": 63.0,
"bytesScanned": 11802.0
}
and a long array of function reports found for a given time period.
[
{
"field": "@timestamp",
"value": "2020-01-21 15:24:18.198"
},
{
"field": "@message",
"value": "REPORT RequestId: 33792b95-4e1f-4c69-a5f5-5dacea2067cd\tDuration: 25.98 ms\tBilled Duration: 100 ms\tMemory Size: 512 MB\tMax Memory Used: 54 MB\tInit Duration: 1.01 ms\t\n"
},
{
"field": "@ptr",
"value": "CnYKPQo5MjYxNDkwODAzNzQ5Oi9hd3MvbGFtYmRhLzQxMV9pbWFnZV9yZWNvZ25pdGlvbl9weXRob25fNTEyEAUSNRoYAgXVWRJZAAAAAMQBWcsABeJxcZAAAACSIAEolaPRxfwtMJaj0cX8LTgDQNwESJ8XUJ0REAIYAQ=="
}
]
And what about function result? Well, in that case it’s ignored and the only solution
to retain it is to export function result into a dedicated S3 bucket.
The context
argument to every lambda function includes request identification
`context.aws_request_id’ which can be used to connect output in storage with
CloudWatch logs.


| plot.mitml {mitml} | R Documentation |
Generates diagnostic plots for assessing the convergence and autocorrelation behavior of pan
's and jomo
's MCMC algorithms.
## S3 method for class 'mitml' plot(x, print = c("beta", "beta2", "psi", "sigma"), pos = NULL, group = "all", trace = c("imputation", "burnin", "all"), thin = 1, smooth = 3, n.Rhat = 3, export = c("none", "png", "pdf"), dev.args = list(), ...)
x |
An object of class |
print |
A character vector containing one or several of |
pos |
Either |
group |
Either |
trace |
One of |
thin |
An integer denoting the thinning factor that is applied before plotting. Default is |
smooth |
A numeric value denoting the smoothing factor for the trend line in trace plots. Higher values correspond to less smoothing. Default is |
n.Rhat |
An integer denoting the number of segments of each chain used for calculating the potential scale reduction factor. Default is |
export |
(optional) A character string specifying if plots should be exported to a file. If |
dev.args |
(optional) A named list containing additional arguments that are passed to the graphics device. |
... |
Parameters passed to the plotting functions. |
The plot
method generates a series of plots for the parameters of the imputation model which can be used for diagnostic purposes.
In addition, a short summary of the parameter chain is displayed.
Setting print
to "beta"
, "beta2"
, "psi"
and "sigma"
will plot the fixed effects, the variances and covariances of the random effects, and the variances and covariances of the residuals, respectively.
In this context, "beta2"
refers to the fixed effects for target variables at level 2 and is only used when a two-part model was specified in (jomoImpute
).
Each plotting window contains a trace plot (upper left), an autocorrelation plot (lower left), a kernel density approximation of the posterior distribution (upper right), and a posterior summary (lower right).
The summary includes the following quantities:
EAP
:Expected value a posteriori (i.e., the mean of the parameter chain)
MAP
:Mode a posteriori (i.e., the mode of the parameter chain)
SD
:Standard deviation of the parameter chain
2.5%
:The 2.5% quantile of parameter values
97.5%
:The 97.5% quantile of parameter values
Rhat
:Estimated potential scale reduction factor (\hat{R})
ACF-k
:Smoothed autocorrelation at lag k, where k is the number of iterations between imputations (see summary.mitml
)
The trace
and smooth
arguments can be used to influence how the trace plot is drawn and what part of the chain should be used for it.
The thin
argument can be used for thinning the chain before plotting, in which case the number of data points is reduced in the trace plot, and the autocorrelation is calculated up to lag k/thin (see above).
The n.Rhat
argument controls the number of segments that are used for calculating the potential scale reduction factor (\hat{R}) in each plot (see summary.mitml
).
Further aguments to the graphics device are supplied using the dev.args
argument.
The plot
function computes and displays diagnostic information primarily for the imputation phase (i.e., for iterations after burn-in).
This is the default in the plot
function and the recommended method for most users.
If trace = "all"
, the full chain is displayed with emphasis on the imputation phase, and the posterior summary is calculated based on only the iterations after burn-in (as recommended).
If trace = "burnin"
, the posterior summary and the trace plots are calculated based on only the burn-on interations, which is generally not sufficient to establish convergence and should be used with caution.
None (invisible NULL
).
The plots are presented on-screen one at a time. To proceed with the next plot, the user may left-click in the plotting window or press the "enter" key while in the R console, depending on the operating system. No plots are displayed when exporting to file.
Simon Grund
panImpute
, jomoImpute
, summary.mitml
## Not run: data(studentratings) # * Example 1: simple imputation fml <- ReadDis + SES ~ ReadAchiev + (1|ID) imp <- panImpute(studentratings, formula = fml, n.burn = 1000, n.iter = 100, m = 5) # plot all parameters (default) plot(imp) # plot fixed effects only plot(imp, print = "beta") # export plots to file (using pdf device) plot(imp, export = "pdf", dev.args = list(width = 9, height = 4, pointsize = 12)) # * Example 2: groupwise imputation fml <- ReadDis + SES ~ ReadAchiev + (1|ID) imp <- panImpute(studentratings, formula = fml, group = FedState, n.burn = 1000, n.iter = 100, m = 5) # plot fixed effects for all groups (default for 'group') plot(imp, print = "beta", group = "all") # plot fixed effects for first group only plot(imp, print = "beta", group = 1) ## End(Not run)


First, a test of familiar HTML block level elements. We have already seen h1, h2 and p, so here are the rest of the headings:
Sometimes it is useful to include larger blocks of preformatted text, which is typically rendered using a monospace font. This is useful when attempting to create diagrams using text:
Top ---> +----+ | | Bottom ---> +----+


--- layout: page title: about description: "仰天大笑出门去，我辈岂是蓬蒿人。" header-img: "img/home-bg-o.jpg" ---
A man's station is limited only by his imagination.
学士：2008.9 ~ 2012.6，哈尔滨工业大学，交通工程 硕士：2012.9 ~ 2015.6，大连理工大学，交通运输规划与管理 博士：2015.9 ~ 2020.2，Eindhoven University of Technology，Urban Planning and Transportation
Pan, X., & Zuo, Z. (2020). Exploring the role of utility-difference threshold in choice behavior: An empirical case study of bus service choice. International Journal of Transportation Science and Technology. (published online)
Pan, X. (2019). Investigating college students’ choice of train trips for homecoming during the Spring Festival travel rush in China: Results from a stated preference approach. Transportation Letters: The International Journal of Transportation Research. (published online)
Pan, X., & Zuo, Z. (2019). Investigating travelers’ heterogeneous attitudes toward losses: Insights from a stated preference experiment. Transportation Letters: The International Journal of Transportation Research. (published online)
Pan, X., Rasouli, S., & Timmermans, H. (2019). Modeling social influence using sequential stated adaptation experiments: A study of city trip itinerary choice. Transportation Research Part A: Policy and Practice, 130, 652-672.
Pan, X., & Zuo, Z. (2014). A stochastic user equilibrium model and optimal congestion pricing with prospect theory. Procedia - Social and Behavioral Sciences, 138, 127~136.
左志, 潘晓锋, 王涛 & 刘锴. (2016). 基于模拟通行能力退化的关键路段识别——以乌鲁木齐市为例. 大连交通大学学报, 37(4), 10~13+37.
左志, 王涛, 潘晓锋 & 刘锴. (2016). 基于通勤行为的电动汽车充电站选址模型. 武汉理工大学学报（交通科学与工程版）, 40(2), 233~237.
左志, 王涛 & 潘晓锋. (2015). 基于路网可靠性的关键点段辨识——以乌鲁木齐市为例. 交通运输研究, 1(5), 18~24.
左志 & 潘晓锋. (2014). 基于有限理性的交通方式划分模型. 大连理工大学学报, 54(5), 531~536.
潘晓锋, 左志 & 赵胜川. (2014). 基于前景理论的改进多路径交通分配模型. 交通运输系统工程与信息, 14(2), 162~167.
Zuo, Z., & Pan, X. (2019). Determinants of college students choosing railway during the Spring Festival travel rush in China: Preliminary results using stated preference approach. In Proceedings of CICTP 2019: Transportation in China - Connecting the World.
Zuo, Z., Pan, X., Wang, L., & Feng, T. (2019). Stochastic traffic-assignment with multi-modes based on bounded rationality. In International Symposium for Intelligent Transportation and Smart City (ITASC) 2019 Proceedings.
Pan, X., Rasouli, S., & Timmermans, H. (2018). Towards a two-stage model of social influence using sequential stated adaptation experiments. In Proceedings of HKSTS 2018: Transportation Systems in the Connected Era.
Pan, X., Rasouli, S., & Timmermans, H. (2018). Effect of social influence on consumer choice behavior using a sequential stated choice experiment: A study of city trip itinerary choice. In Proceedings of 97th Annual Meeting of the Transportation Research Board.
Zuo, Z., & Pan, X. (2018). Prospect theory-based travel choice behavior modeling: State of the art and critical issues. In Proceedings of CICTP 2017: Transportation Reform and Change - Equity, Inclusiveness, Sharing, and Innovation.
Pan, X., Rasouli, S., & Timmermans, H. (2017). Advancing relative utility maximization models: Application to leisure choice behavior. In Proceedings of the BIVEC-GIBET Transport Research Days 2017: Towards an Autonomous and Interconnected Transport Future.
Pan, X., Rasouli, S., & Timmermans, H. (2016). Modeling bounded rationality in choice behavior: Relative utility vs. random regret models. In Proceedings of 13th International Conference on Design & Decision Support Systems in Architecture and Urban Planning.
Zuo, Z., Pan, X., & Liu, K. (2015). Parameter calibration in cumulative prospect theory for travelers’ route choice behavior. In Proceedings of CICTP 2015: Efficient, Safe, and Green Multimodal Transportation.
Zuo, Z., & Pan, X. (2019). An ordered scobit model with heterogeneous loss attitude: A study of commuters’ bus line satisfaction. Presented in 2019 World Transport Convention, 13~16 Jun. 2019, Beijing, China.
Pan, X., Rasouli, S., & Timmermans, H. (2018). Separating effects of social influence and choice consistency in sequential stated adaptation experiments. Presented in 7th Symposium of the European Association for Research in Transportation, 5~7 Sep. 2018, Athens, Greece.
Pan, X., & Zuo, Z. (2013). Analysis of travel choice behavior under congestion pricing based on cumulative prospect theory. Presented in 1st International Conference on Public-Private Partnerships, 5~7 Aug. 2013, Dalian, China.


Show a phone number and let a external application call the number
Watch a video in your browser
Use DOCTYPE to specify the type of the document the browser consumes.
Use a canvas to create a space where you can draw funny images.
Use mark to highlight parts of text.


{% extends 'blog/base.html' %} {% load markdown_deux_tags %} {% block title %}
Want to get in touch? Fill out the form below to send me a message and I will get back to you as soon as possible!


A portfolio theme for creativer folks
We are experienced and well established Themeforest author for more than 5 years. We are one of the best support author on the market.
When we design and create Grand Portfolio theme. We want to provide you tools for building portfolio focus site. So we craftly created designed demos which built with our theme options and features and no coding required. Each demos are included for free and can be easily imported with one click using our theme admin.
When we design and create Grand Portfolio theme. We want to provide you tools for building portfolio focus site. So we craftly created designed demos which built with our theme options and features and no coding required. Each demos are included for free and can be easily imported with one click using our theme admin.
We love beautiful architecture so we want to create a clean portfolio layout for architects to show off their works
We love beautiful architecture so we want to create a clean portfolio layout for architects to show off their works
We love beautiful architecture so we want to create a clean portfolio layout for architects to show off their works
We love beautiful architecture so we want to create a clean portfolio layout for architects to show off their works
We love beautiful architecture so we want to create a clean portfolio layout for architects to show off their works
We love beautiful architecture so we want to create a clean portfolio layout for architects to show off their works
hi
fuck
hi
welcome
hi
welcome
hi
welcome
hi
welcome
hi
welcome
Lorem ipsum dosectetur adipisicing elit, sed do.Lorem ipsum dolor sit amet, consectetur Nulla fringilla purus at leo dignissim congue.
732/21 Second Street, Manchester, King Street,Kingston United Kingdom
(65)323-678-567


--- layout: post title: Me so sad :( date: 2009-05-06 09:26:21.000000000 +02:00 categories: [] tags: [] status: publish type: post published: true meta: _edit_last: '5236424' author: login: stricksucht email<EMAIL_ADDRESS>display_name: stricksucht first_name: '' last_name: '' ---
I just started to rip the Print O'The Wave Stole apart, because I finally figured my long tail cast-on would be too unflexible for blocking. All the work for nothing :( And I should have known it better!  Since the original pattern uses a two-part center panel with 17 pattern repeats each and I want to spare myself the grafting, I'm knitting the center panel in one piece. So that makes 34 pattern repeats or 34 days until I'm done with the center panel. Nearly five weeks. SIGH!! (I truely hope Anna never ever will read this!) Please, please, please don't ask me about what I'm going to do when it comes to the edging, I haven't thought about it yet. (With almost five weeks to go, I don't think I'll have to ;))
And now I'm going to study "Cabling without a cable needle" again, because I never can remember how it's done exactly when I haven't worked on a piece for some time, so I can go on with my Honeycomb vest. I'm not in the mood to wrap my head around methods for Invisible Cast-Ons, the pain is just too fresh...


Applying for foundation degree awarding powers: companion guide
This publication
was withdrawn on
Department for Business, Innovation and Skills is currently reviewing the criteria and guidance for degree awarding powers, university title and designation for alternative providers to become HEFCE funded.
Read more about the review
.
If you use assistive technology (such as a screen reader) and need a
version of this document in a more accessible format, please email
<EMAIL_ADDRESS>.
Please tell us what format you need. It will help us if you say what assistive technology you use.
Details
Explains the application process for further education colleges seeking their own UK foundation degree awarding powers. Applies to institutions in England and Wales only. See also URN 11/782 for guidance and criteria.


The algorithm implemented in this package was designed to quickly estimates the distribution of the log-rank especially for heavy unbalanced groups. VALORATE estimates the null distribution and the p-value of the log-rank test based on a recent formulation. For a given number of alterations that define the size of survival groups, the estimation involves a weighted sum of distributions that are conditional on a co-occurrence term where mutations and events are both present. The estimation of conditional distributions is quite fast allowing the analysis of large datasets in few minutes <http://bioinformatica.mty.itesm.mx/valorate>.
| Version: | 1.0-1 |
| Depends: | R (≥ 3.1.0), methods |
| Imports: | survival, graphics, utils, stats |
| Published: | 2016-10-09 |
| Author: | Victor Trevino [aut, cre] |
| Maintainer: | Victor Trevino <vtrevino at itesm.mx> |
| License: | GPL-2 | GPL-3 [expanded from: GPL (≥ 2)] |
| URL: | http://bioinformatica.mty.itesm.mx/valorate |
| NeedsCompilation: | yes |
| CRAN checks: | valorate results |
| Reference manual: | valorate.pdf |
| Package source: | valorate_1.0-1.tar.gz |
| Windows binaries: | r-devel: valorate_1.0-1.zip, r-release: valorate_1.0-1.zip, r-oldrel: valorate_1.0-1.zip |
| OS X binaries: | r-release: valorate_1.0-1.tgz, r-oldrel: valorate_1.0-1.tgz |
| Old sources: | valorate archive |
Please use the canonical form https://CRAN.R-project.org/package=valorate to link to this page.


§516-5 Penalty. Any person who violates this chapter shall be fined not more than $5,000 nor less than $1,000 or imprisoned not more than one year, or both. [L 1967, c 307, §6; HRS §516-5; am L 2015, c 237, §37]


Pat's Salmon Cookies
Home
Sales
Merchandise
Order
Location Sales By Time and Location
Total hourly sales
Add New Store Location
New Store Location
Daily minimum customer average
Daily maximum customer average
Daily average cookie sale per customer
submit


Robredo: QC barangay shows 'it takes a village' to solve drug menace
Vice President Leni Robredo visits Barangay Culiat in Quezon City to understand how local officials, the police, civil society, and the private sector contributed to its anti-illegal drug campaign
by Mara CepedaSubscribe
Email Address
Newsletters
- Glenda Gloria's Take this Tuesday
- Huddle by Miriam Grace Go
- The Newsbreak Agenda by Chay Hofileña
- Sometimes, all you need is video by Lilibeth Frondoso


Employee registration app
Employee registration app
Provide the below details:
First Name:
Last Name:
Sex:
male
female
Date of Birth:
(mm-dd-yy)
Email Address:
Service Level:


Heartworm is a serious illness where worms actually invade the heart of an otherwise healthy pet, after the pet has been inflicted with a bite from an infected mosquito. If you live in a location where mosquitoes are common, and/or your veterinarian has indicated that heartworm is a local threat, it’s important to get your pet on heartworm preventative medication.


{{github.bio}}
{{github.location}}
Repositories{{github.public_repos}}
Followers{{github.followers}}
Following{{github.following}}
Created On{{github.created_at|date}}
{{arr.name}}


For DEBUG Logging
Actor wrapper around the standard output logger.
Actor wrapper around the standard output logger. If
akka.loggers
is not set, it defaults to just this
logger.
For ERROR Logging
For INFO Logging
Message which is sent to each default logger (i.e.
Message which is sent to each default logger (i.e. from configuration file) after its creation but before attaching it to the logging bus. The logger actor must handle this message, it can be used e.g. to register for more channels. When done, the logger must respond with a LoggerInitialized message. This is necessary to ensure that additional subscriptions are in effect when the logging system finished starting.
Base type of LogEvents
Exception that wraps a LogEvent.
Marker trait for annotating LogLevel, which must be Int after erasure.
Artificial exception injected into Error events if no Throwable is supplied; used for getting a stack dump of error locations.
LoggerInitializationException is thrown to indicate that there was a problem initializing a logger
Response message each logger must send within 1 second after receiving the InitializeLogger request.
Response message each logger must send within 1 second after receiving the InitializeLogger request. If initialization takes longer, send the reply as soon as subscriptions are set-up.
Actor-less logging implementation for synchronous logging to standard output.
Actor-less logging implementation for synchronous logging to standard
output. This logger is always attached first in order to be able to log
failures during application start-up, even before normal logging is
started. Its log level can be defined by configuration setting
akka.stdout-loglevel
.
For WARNING Logging
Log level in numeric form, used when deciding whether a certain log statement should generate a log event.
Log level in numeric form, used when deciding whether a certain log statement should generate a log event. Predefined levels are ErrorLevel (1) to DebugLevel (4). In case you want to add more levels, loggers need to be subscribed to their event bus channels manually.
Obtain LoggingAdapter with MDC support for the given actor.
Obtain LoggingAdapter with MDC support for the given actor. Don't use it outside its specific Actor as it isn't thread safe
Obtain LoggingAdapter for the given logging bus and source object.
Obtain LoggingAdapter for the given logging bus and source object.
The source is used to identify the source of this logging channel and must have a corresponding implicit LogSource[T] instance in scope; by default these are provided for Class[_], Actor, ActorRef and String types. See the companion object of akka.event.LogSource for details.
You can add your own rules quite easily, see akka.event.LogSource.
Note that this LoggingAdapter
will use the akka.event.DefaultLoggingFilter,
and not the akka.event.LoggingFilter configured for the system
(if different from DefaultLoggingFilter
).
Obtain LoggingAdapter for the given actor system and source object.
Obtain LoggingAdapter for the given actor system and source object. This will use the system’s event stream and include the system’s address in the log source string.
Do not use this if you want to supply a log category string (like
“com.example.app.whatever”) unaltered, supply system.eventStream
in this
case or use
Logging(system, this.getClass)
The source is used to identify the source of this logging channel and must have a corresponding implicit LogSource[T] instance in scope; by default these are provided for Class[_], Actor, ActorRef and String types. See the companion object of akka.event.LogSource for details.
You can add your own rules quite easily, see akka.event.LogSource.
Returns the event class associated with the given LogLevel
Obtain LoggingAdapter with MDC support for the given actor.
Obtain LoggingAdapter with MDC support for the given actor. Don't use it outside its specific Actor as it isn't thread safe
Obtain LoggingAdapter with MDC support for the given actor.
Obtain LoggingAdapter with MDC support for the given actor. Don't use it outside its specific Actor as it isn't thread safe
Obtain LoggingAdapter for the given logging bus and source object.
Obtain LoggingAdapter for the given logging bus and source object.
The source is used to identify the source of this logging channel and must have a corresponding implicit LogSource[T] instance in scope; by default these are provided for Class[_], Actor, ActorRef and String types. See the companion object of akka.event.LogSource for details.
Note that this LoggingAdapter
will use the akka.event.DefaultLoggingFilter,
and not the akka.event.LoggingFilter configured for the system
(if different from DefaultLoggingFilter
).
Obtain LoggingAdapter for the given actor system and source object.
Obtain LoggingAdapter for the given actor system and source object. This will use the system’s event stream and include the system’s address in the log source string.
Do not use this if you want to supply a log category string (like
“com.example.app.whatever”) unaltered, supply system.eventStream
in this
case or use
Logging.getLogger(system, this.getClass());
The source is used to identify the source of this logging channel and must have a corresponding implicit LogSource[T] instance in scope; by default these are provided for Class[_], Actor, ActorRef and String types. See the companion object of akka.event.LogSource for details.
Returns the LogLevel associated with the given event class.
Returns the LogLevel associated with the given event class. Defaults to DebugLevel.
Returns the LogLevel associated with the given string, valid inputs are upper or lowercase (not mixed) versions of: "error", "warning", "info" and "debug"
Java API to create a LoggerInitialized message.
Class name representation of a message.
Class name representation of a message.
ActorSelectionMessage
representation includes class name of
wrapped message.
Returns a 'safe' getSimpleName for the provided Class
Returns a 'safe' getSimpleName for the provided Class
the simple name of the given Class
Returns a 'safe' getSimpleName for the provided object's Class
Returns a 'safe' getSimpleName for the provided object's Class
the simple name of the given object's Class
Returns the StackTrace for the given Throwable as a String
Main entry point for Akka logging: log levels and message types (aka channels) defined for the main transport medium, the main event bus. The recommended use is to obtain an implementation of the Logging trait with suitable and efficient methods for generating log events:
The source object is used in two fashions: its
Class[_]
will be part of all log events produced by this logger, plus a string representation is generated which may contain per-instance information, seeapply
orcreate
below.Loggers are attached to the level-specific channels
Error
,Warning
,Info
andDebug
as appropriate for the configured (or set) log level. If you want to implement your own, make sure to handle these four event types plus theInitializeLogger
message which is sent before actually attaching it to the logging bus.Logging is configured by setting (some of) the following:


---
layout: post
title: "C# will eventually get all F# features, right?"
description: "C# will never get the important features that F# has. Here's why."
date: 2015-04-15 8:32 UTC
tags: [Languages, F#]
---
{% include JB/setup %}
{{ page.description }}
The relationship between C# and F# is interesting, no matter if you look at it from the C# or the F# perspective:
-
Before releasing F# to the world, Don Syme, its inventor, was instrumental in getting generics into C# and .NET. Had it not been for his and his Cambridge colleagues' effort, we wouldn't have generics today, or we would have the subpar generics that Java has. (Okay, so this point isn't strictly about F#.)
-
F# has had async workflows since 2007. In F#, this is simply one of many implementations of a more general language feature called Computation Expressions - other common examples are Sequence Expressions and Query Expressions, but you can also create your own. When async/await was added to C# in 2012, it was a port of that particular implementation, but turned into a one-shot language feature.
-
C# 6 gets a lot of small language features, some of which F# already has: auto-property initializers, exception filters, expression-bodied function members...
-
For C# 7, the design team is considering many Functional language features that F# already has: pattern matching, records, immutability, tuples...
There's nothing wrong with this. F# is a great language, so obviously it makes sense to look there for inspiration. Some features also go the other way, such as F# Query Expressions, which were inspired by LINQ.
It's not some hidden cabal that I'm trying to expose, either. Mads Torgersen has been quite open about this relationship.
Why care about F#, then? #
A common reaction to all of this seems to be that if C# eventually gets all the best F# features, there's no reason to care about F#. Just stick with C#, and get those features in the future.
The most obvious answer to such statements is that F# already has those features, while you'll have to wait for a long time to get them in C#. While C# 6 gets a few features, they are hardly killer features. So perhaps you'll get the good F# features in C#, but they could be years away, and some features might be postponed to later versions again.
In my experience, that argument mostly falls on deaf ears. Many programmers are content to wait, perhaps because they feel that the language choice is out of their hands anyway.
What F# features could C# get? #
Often, when F# enthusiasts attempt to sell the language to other programmers, they have a long list of language features that F# has, and that (e.g.) C# doesn't have. However, in the future, C# could hypothetically have those features too:
-
Records. C# could have those as well, and they're being considered for C# 7. Implementation-wise, F# records compile to immutable classes anyway.
-
Discriminated Unions. Nothing in principle prevents C# from getting those. After all, F# Discriminated Unions compile to a class hierarchy.
-
Pattern matching Also being considered for C# 7.
-
No nulls. It's a common myth that F# doesn't have nulls. It does. It's even a keyword. It's true that F# doesn't allow its Functional data types (records, unions, tuples, etc.) to have null values, but it's only a compiler trick. At run-time, these types can have null values too, and you can provide null values via Reflection. C# could get such a compiler trick as well.
-
Immutability. F#'s immutability 'feature' is similar to how it deals with nulls. Lots of F# can be mutable (everything that interacts with C# code), but the special Functional data types can't. Again, it's mostly in how these specific data types are implemented under the hood that provides this feature, and C# could get that as well.
-
Options. These are really just specialised Discriminated Unions, so C# could get those too.
-
Object Expressions. Java has had those for years, so there's no reason C# couldn't get them as well.
-
Partial Function Application. You can already do this in C# today, but the syntax for it is really awkward. Thus, there's no technical reason C# can't have that, but the C# language designers would have to come up with a better syntax.
-
Scripting. F# is great for scripting, but as the success of scriptcs has shown, nothing prevents C# from being a scripting language either.
-
REPL. A REPL is a really nice tool, but scriptcs already comes with a REPL, again demonstrating that C# could have that too.
This list
in no way implies that C# will get any or all of these features. While
I'm an MVP, I have no inside insight; I'm only speculating. My point is that I see no fundamental reason C# couldn't eventually get those features.
What F# features can C# never get? #
There are a few F# features that many people point to as their favourite, that C# is unlikely to get. A couple of them are:
-
Type Providers. Someone that I completely trust on this issue told me quite authoritatively that "C# will never get Type Providers", and then laughed quietly. While I don't know enough about the technical details of Type Providers to be able to evaluate that statement, I trust this person completely on this issue.
-
Units of Measure. Here, I simply have to confess ignorance. While I haven't seen talk about units of measure for C#, I have no idea whether it's doable or not.
These are some loved features of F# that look unlikely to be ported to C#, but there's one quality of F# that I'm absolutely convinced will
never make it to C#, and this is
one of the killer features of F#: it's what you
can't do in the language.
In a recent article, I explained how less is more when it comes to language features. Many languages come with redundant features (often for historical reasons), but the fewer redundant features a language has, the better.
The F# compiler doesn't allow circular dependencies. You can't use a type or a function before you've defined it. This may seem like a restriction, but is perhaps the most important quality of F#. Cyclic dependencies are closely correlated with coupling, and coupling is the deadliest maintainability killer of code bases.
In C# and most other languages, you can define dependency cycles, and the compiler makes it easy for you. In F#, the compiler makes it impossible.
Studies show that F# projects have fewer and smaller cycles, and that there are types of cycles (motifs) you don't see at all in F# code bases.
The F# compiler protects you from making cycles. C# will never be able to do that, because it would be a massive breaking change: if the C# compiler was changed to protect you as well, most existing C# code wouldn't be able to compile.
Microsoft has never been in the habit of introducing breaking changes, so I'm quite convinced that this will never happen.
Summary #
C# could, theoretically, get a lot of the features that F# has, but not the 'feature' that really matters: protection against coupling. Since coupling is one of the most common reasons for code rot, this is one of the most compelling reasons to switch to F# today.
F# is a great language, not only because of the features it has, but even more so because if the undesirable traits it doesn't have.
Comments
I would say C# won't get non-nullable reference types either, even in the form of a compiler trick. It would either introduce too much of breaking changes or be very limited and thus not especially usefull.
Vladimir, thank you for writing. You're probably correct. Many years ago, I overheard Anders Hejlsberg say that it wouldn't be possible to introduce non-nullable reference types into the .NET platform without massive breaking changes. I can't say I ever understood the reasoning behind this (nor was it ever explained to me), but when Anders Hejlsberg tells you that, you sort of have to accept it :)
FWIW, there's a bit of discussion about non-nullable reference types in the C# Design Meeting Notes for Jan 21, 2015, but I have to admit that I didn't follow the link to Eric Lippert's blog :$