Functions | |
| piojo_tree_t * | piojo_tree_alloc_intk (size_t evsize) |
| piojo_tree_t * | piojo_tree_alloc_i32k (size_t evsize) |
| piojo_tree_t * | piojo_tree_alloc_i64k (size_t evsize) |
| piojo_tree_t * | piojo_tree_alloc_ptrk (size_t evsize) |
| piojo_tree_t * | piojo_tree_alloc_sizk (size_t evsize) |
| piojo_tree_t * | piojo_tree_alloc_cb_intk (uint8_t maxchildren, size_t evsize, piojo_alloc_kv_if allocator) |
| piojo_tree_t * | piojo_tree_alloc_cb_i32k (uint8_t maxchildren, size_t evsize, piojo_alloc_kv_if allocator) |
| piojo_tree_t * | piojo_tree_alloc_cb_i64k (uint8_t maxchildren, size_t evsize, piojo_alloc_kv_if allocator) |
| piojo_tree_t * | piojo_tree_alloc_cb_ptrk (uint8_t maxchildren, size_t evsize, piojo_alloc_kv_if allocator) |
| piojo_tree_t * | piojo_tree_alloc_cb_sizk (uint8_t maxchildren, size_t evsize, piojo_alloc_kv_if allocator) |
| piojo_tree_t * | piojo_tree_alloc_cmp (size_t evsize, piojo_cmp_cb keycmp, size_t eksize) |
| piojo_tree_t * | piojo_tree_alloc_cb_cmp (uint8_t maxchildren, size_t evsize, piojo_cmp_cb keycmp, size_t eksize, piojo_alloc_kv_if allocator) |
| piojo_tree_t * | piojo_tree_copy (const piojo_tree_t *tree) |
| void | piojo_tree_free (const piojo_tree_t *tree) |
| void | piojo_tree_clear (piojo_tree_t *tree) |
| size_t | piojo_tree_size (const piojo_tree_t *tree) |
| bool | piojo_tree_insert (const void *key, const void *data, piojo_tree_t *tree) |
| bool | piojo_tree_set (const void *key, const void *data, piojo_tree_t *tree) |
| void * | piojo_tree_search (const void *key, const piojo_tree_t *tree) |
| bool | piojo_tree_delete (const void *key, piojo_tree_t *tree) |
| piojo_tree_node_t * | piojo_tree_first (const piojo_tree_t *tree, piojo_tree_node_t *node) |
| piojo_tree_node_t * | piojo_tree_last (const piojo_tree_t *tree, piojo_tree_node_t *node) |
| piojo_tree_node_t * | piojo_tree_next (piojo_tree_node_t *node) |
| piojo_tree_node_t * | piojo_tree_prev (piojo_tree_node_t *node) |
| const void * | piojo_tree_entryk (const piojo_tree_node_t *node) |
| void * | piojo_tree_entryv (const piojo_tree_node_t *node) |
Variables | |
| const size_t | piojo_tree_sizeof |
Piojo B-tree implementation. Use maxchildren >= 8 for good performance.
| piojo_tree_t* piojo_tree_alloc_cb_cmp | ( | uint8_t | maxchildren, |
| size_t | evsize, | ||
| piojo_cmp_cb | keycmp, | ||
| size_t | eksize, | ||
| piojo_alloc_kv_if | allocator | ||
| ) |
Allocates a new tree.
| [in] | maxchildren | Maximum children in each node (from 4 to 254, and multiple of 2). |
| [in] | evsize | Entry value size in bytes. |
| [in] | keycmp | Entry key comparison function. |
| [in] | eksize | Entry key size. |
| [in] | allocator | Allocator to be used. |
| piojo_tree_t* piojo_tree_alloc_cb_i32k | ( | uint8_t | maxchildren, |
| size_t | evsize, | ||
| piojo_alloc_kv_if | allocator | ||
| ) |
Allocates a new tree. Uses key size of int32_t.
| [in] | maxchildren | Maximum children in each node (from 4 to 254, and multiple of 2). |
| [in] | evsize | Entry value size in bytes. |
| [in] | allocator | Allocator to be used. |
| piojo_tree_t* piojo_tree_alloc_cb_i64k | ( | uint8_t | maxchildren, |
| size_t | evsize, | ||
| piojo_alloc_kv_if | allocator | ||
| ) |
Allocates a new tree. Uses key size of int64_t.
| [in] | maxchildren | Maximum children in each node (from 4 to 254, and multiple of 2). |
| [in] | evsize | Entry value size in bytes. |
| [in] | allocator | Allocator to be used. |
| piojo_tree_t* piojo_tree_alloc_cb_intk | ( | uint8_t | maxchildren, |
| size_t | evsize, | ||
| piojo_alloc_kv_if | allocator | ||
| ) |
Allocates a new tree. Uses key size of int.
| [in] | maxchildren | Maximum children in each node (from 4 to 254, and multiple of 2). |
| [in] | evsize | Entry value size in bytes. |
| [in] | allocator | Allocator to be used. |
| piojo_tree_t* piojo_tree_alloc_cb_ptrk | ( | uint8_t | maxchildren, |
| size_t | evsize, | ||
| piojo_alloc_kv_if | allocator | ||
| ) |
Allocates a new tree. Uses key size of uintptr_t.
| [in] | maxchildren | Maximum children in each node (from 4 to 254, and multiple of 2). |
| [in] | evsize | Entry value size in bytes. |
| [in] | allocator | Allocator to be used. |
| piojo_tree_t* piojo_tree_alloc_cb_sizk | ( | uint8_t | maxchildren, |
| size_t | evsize, | ||
| piojo_alloc_kv_if | allocator | ||
| ) |
Allocates a new tree. Uses key size of size_t.
| [in] | maxchildren | Maximum children in each node (from 4 to 254, and multiple of 2). |
| [in] | evsize | Entry value size in bytes. |
| [in] | allocator | Allocator to be used. |
| piojo_tree_t* piojo_tree_alloc_cmp | ( | size_t | evsize, |
| piojo_cmp_cb | keycmp, | ||
| size_t | eksize | ||
| ) |
Allocates a new tree. Uses default allocator.
| [in] | evsize | Entry value size in bytes. |
| [in] | keycmp | Entry key comparison function. |
| [in] | eksize | Entry key size. |
| piojo_tree_t* piojo_tree_alloc_i32k | ( | size_t | evsize | ) |
Allocates a new tree. Uses default allocator and key size of int32_t.
| [in] | evsize | Entry value size in bytes. |
| piojo_tree_t* piojo_tree_alloc_i64k | ( | size_t | evsize | ) |
Allocates a new tree. Uses default allocator and key size of int64_t.
| [in] | evsize | Entry value size in bytes. |
| piojo_tree_t* piojo_tree_alloc_intk | ( | size_t | evsize | ) |
Allocates a new tree. Uses default allocator and key size of int.
| [in] | evsize | Entry value size in bytes. |
| piojo_tree_t* piojo_tree_alloc_ptrk | ( | size_t | evsize | ) |
Allocates a new tree. Uses default allocator and key size of uintptr_t.
| [in] | evsize | Entry value size in bytes. |
| piojo_tree_t* piojo_tree_alloc_sizk | ( | size_t | evsize | ) |
Allocates a new tree. Uses default allocator and key size of size_t.
| [in] | evsize | Entry value size in bytes. |
| void piojo_tree_clear | ( | piojo_tree_t * | tree | ) |
Deletes all entries in tree.
| [out] | tree | Tree being cleared. |
| piojo_tree_t* piojo_tree_copy | ( | const piojo_tree_t * | tree | ) |
Copies tree and all its entries.
| [in] | tree | Tree being copied. |
| bool piojo_tree_delete | ( | const void * | key, |
| piojo_tree_t * | tree | ||
| ) |
Deletes an entry by key.
| [in] | key | Entry key. |
| [out] | tree |
| const void* piojo_tree_entryk | ( | const piojo_tree_node_t * | node | ) |
Reads node entry key.
| [in] | node |
| void* piojo_tree_entryv | ( | const piojo_tree_node_t * | node | ) |
Reads node entry value.
| [in] | node |
| piojo_tree_node_t* piojo_tree_first | ( | const piojo_tree_t * | tree, |
| piojo_tree_node_t * | node | ||
| ) |
Reads the first node in tree (order given by keycmp function).
| [in] | tree | |
| [out] | node |
| void piojo_tree_free | ( | const piojo_tree_t * | tree | ) |
Frees tree and all its entries.
| [in] | tree | Tree being freed. |
| bool piojo_tree_insert | ( | const void * | key, |
| const void * | data, | ||
| piojo_tree_t * | tree | ||
| ) |
Inserts a new entry. If data is NULL, the value is replaced with TRUE (useful for sets).
| [in] | key | Entry key. |
| [in] | data | Entry value. |
| [out] | tree | Tree being modified. |
| piojo_tree_node_t* piojo_tree_last | ( | const piojo_tree_t * | tree, |
| piojo_tree_node_t * | node | ||
| ) |
Reads the last node in tree (order given by keycmp function).
| [in] | tree | |
| [out] | node |
| piojo_tree_node_t* piojo_tree_next | ( | piojo_tree_node_t * | node | ) |
Reads the next node (order given by keycmp function).
| [out] | node |
| piojo_tree_node_t* piojo_tree_prev | ( | piojo_tree_node_t * | node | ) |
Reads the previous node (order given by keycmp function).
| [out] | node |
| void* piojo_tree_search | ( | const void * | key, |
| const piojo_tree_t * | tree | ||
| ) |
Searches an entry by key.
| [in] | key | Entry key. |
| [in] | tree |
| bool piojo_tree_set | ( | const void * | key, |
| const void * | data, | ||
| piojo_tree_t * | tree | ||
| ) |
Replaces or inserts an entry. If data is NULL, the value is replaced with TRUE (useful for sets).
| [in] | key | Entry key. |
| [in] | data | Entry value. |
| [out] | tree | Tree being modified. |
| size_t piojo_tree_size | ( | const piojo_tree_t * | tree | ) |
Returns number of entries.
| [in] | tree |
| const size_t piojo_tree_sizeof |
Size of tree in bytes


CLOCK
Section: Linux Programmer's Manual (3)
Updated: 2013-08-19
Index
Return to Main Contents
NAME
clock - determine processor time
SYNOPSIS
#include <time.h>
clock_t clock(void);
DESCRIPTION
The
clock()
function returns an approximation of processor time used by the program.
RETURN VALUE
The value returned is the CPU time used so far as a
clock_t;
to get the number of seconds used, divide by
CLOCKS_PER_SEC.
If the processor time used is not available or its value cannot
be represented, the function returns the value
(clock_t) -1.
CONFORMING TO
C89, C99, POSIX.1-2001.
POSIX requires that
CLOCKS_PER_SEC
equals 1000000 independent
of the actual resolution.
NOTES
The C standard allows for arbitrary values at the start of the program;
subtract the value returned from a call to
clock()
at the start of the program to get maximum portability.
Note that the time can wrap around.
On a 32-bit system where
CLOCKS_PER_SEC
equals 1000000 this function will return the same
value approximately every 72 minutes.
On several other implementations,
the value returned by
clock()
also includes the times of any children whose status has been
collected via
wait(2)
(or another wait-type call).
Linux does not include the times of waited-for children in the
value returned by
clock().
The
times(2)
function, which explicitly returns (separate) information about the
caller and its children, may be preferable.
In glibc 2.17 and earlier,
clock()
was implemented on top of
times(2).
For improved accuracy,
since glibc 2.18, it is implemented on top of
clock_gettime(2)
(using the
CLOCK_PROCESS_CPUTIME_ID
clock).
SEE ALSO
clock_gettime(2),
getrusage(2),
times(2)
Index
- NAME
-
- SYNOPSIS
-
- DESCRIPTION
-
- RETURN VALUE
-
- CONFORMING TO
-
- NOTES
-
- SEE ALSO
-
This document was created by
man2html,
using the manual pages.
Time: 02:55:16 GMT, September 18, 2014


Winter of Code is a platform where technology enthusiasts come together and contribute to tools that solve real-life problems. DSC- IIIT Kalyani proudly announce its first ever open source hackathon, WoC - 2020. We are all set to make Winter of Code 1.0 a great success.
An android app which allows you to draw pictures on a canvas and save them as a picture.
GUI Desktop app in Python with various tools based on dcode.fr
A program that simulates a pandemic based on parameters and hyper-parameters. It generates a data frame of virtual people. And within the program, these people can move from one community to another. They tend to visit landmarks more often than in other places. And a foreigner could only directly go to the landmark of a different community. When the infection starts spreading the government set up lock-down.But the lock-downs aren't absolute. Many tend to disobey.
A Flutter package for trimming videos. This supports retrieving, trimming, and storage of trimmed video files to the file system. Platforms supported: Android, iOS
Combining traits from two parent images to produce a child image (having traits from both based on a ratio) using Variational Auto Encoder.
Demonstration of different algorithms and operations on faces.
This project is a multi-author blog page. It consists of different categories of posts and functionalities of multiple admins with proper credentials login. The frontend will be based on HTML, CSS, and JavaScript and the backend is in PHP
The website you're on is also open to contributions!!
This project is a web application for a member management system. An admin can assign tasks to other users and if he accepts, the task is added to the user's dashboard. This way we can have a record of what all members are doing. The backend is done in Django and Graphene and the frontend will be in React.
This project is the portfolio website of Webwiz. It is beginner-friendly as it is completely based on HTML, CSS and JavaScript.
CodeChef is among the most popular competitive programming platforms despite that the platform lacks advanced search functionalities like searching problems using a set of tags, authors, contests. This tool offers the advanced search functionalities lacking in the CodeChef platform.
This project is the portfolio website of Webwiz. It is beginner-friendly as it is completely based on HTML, CSS and JavaScript.
Rotten Scripts contains amazing and awesome scripts written in Python, JavaScript, Bash, Powershell, and more. Consider this repository as your personal space to find or add any new script that can make life easier for us and the Open Source community too, as a Developer, and find a utility of coding to burst out of boredom. Get started with coding exhilarating scripts that you can use to download PDFs from an Online Source or just to randomly like everyone's Instagram Post.
Text preprocessing is the practice of cleaning and preparing text before applying machine or deep learning models. It can give a huge boost in model accuracy as well as interpretation. There are n no. of ways in which preprocessing can be done Plan is to create a python package which according to source of text such as news, Twitter, Reddit make the best possible choices to give a processed text. Will start by writing general functions for each subtask and build up in Bottom-Up approach.
An open source mobile scanner that can covert your scanned images and cards to pdf.
A flutter application that can be used as a calculator for the number theory course.
Javascript based Data Structure and Algorithm Visualizer
This contest is for all under-graduate students. For successful completion of the contest, project completion/adequate progress is mandatory.
Getting 2 pull requests merged in any of the organizations. This is not strictly necessary, but ensure that your contributions stand out in terms of quality rather than quantity.
near Webel IT-Park, Phase 3, Block A
Kalyani, West Bengal 741235


This code is an attempt to create a reference implementation of the translation between tag=value and FIXML. It attempts to correctly convert valid messages, but it doesn't pay detailed attention to what is valid and what is not. It will spot and reject certain invalid messages, but not all (use the FIXML XSDs to confirm the validity of the message). It is not performance optimised, but does use appropriate datastructures (such as hash maps) to avoid obvious problems.
The definition of the FIX protocol is held in the FIX Repository, and recently (as of 2009 onwards) there has been a new and easier to use version of this known as the Unified FIX Repository. This is known to be the strategic direction.
Vendor supplied tools can import, amend and export this format. They can also generate FIXML XSD schemas from it.
The Unified FIX Repository is therefore the ideal configuration from which to drive FIX tools, such as this FIX Converter (and indeed, an earlier attempt to write a FIX Converter driven off of the FIXML XSDs failed when it was realised that information relating to repeating groups and other areas is missing).
In the Unified FIX Repository, we observe and expect the
version
element be the combination of major version,
minor version, optional service pack and optional extension pack,
and thus to align with these examples :-
FIX.4.4
FIX.5.0
FIX.5.0SP1
FIX.5.0SP2_EP196
The customVersion
element is freeform, and sometimes when
displaying diagnostic information, the FIX converter presents the full
version as version/customVersion
.
FIX has at least two representations: tag=value and FIXML.
tag=value is a compact representation, a typical message might start with :-
8=FIX.4.4<SOH>9=176<SOH>35=D<SOH>49=AFUNDMGR<SOH>56=ABROKER<SOH>34=521...
where <SOH> is ASCII character 1.
FIX Engines typically speak tag=value over network links between each other.
The FAST wire protocol is a compressed version of the tag=value format. We could imagine other compressed variants of tag=value, perhaps using ASN.1, but note that some of the FIX HFT discussion recently has proposed a number of measures that result in a different protocol rather than a different representation of the current protocol.
FIXML is an alternative XML based representation of FIX. A typical example might look like this :-
<FIXML xmlns="http://www.fixprotocol.org/FIXML-4-4" v="4.4"> <Order ID="123456" Side="2" TxnTm="2001-09-11T09:30:47-05:00" Typ="2" Px="93.25" Acct="26522154"> <Hdr Snt="2001-09-11T09:30:47-05:00" PosDup="N" PosRsnd="N" SeqNum="521" SID="AFUNDMGR" TID="ABROKER"/> <Instrmt Sym="IBM" ID="459200101" Src="1"/> <OrdQty Qty="1000"/> </Order> </FIXML>
FIX in this representation can be easier to process, due to the ready availability of standard and open XML tools.
Many corporate messaging systems are XML based, in order to handle ISO 20022, FpML, XBRL and SWIFT (as MT/XML). Being able to represent FIX as FIXML can enable the processing of FIX by these messaging systems.
This further enables the use of the FIXML XSDs for message validation, the use of XSLT, Schematron or ISO Schematron for cross-field validation, and even the use of XQuery rules for cross-field validation. Routing and triggering based upon XPath expression is also enabled.
The use of FIXML instead of tag=value is usually at a non-trivial performance cost, and may not be for everyone. Therefore FIXML may play less in the pre-trade space, and more in the post-trade space.
Prior to FIX.4.4, the FIXML representations are defined by DTD, not by XSD.
The Unified FIX Repository annotates them with fixml="0"
suggesting that schemas shouldn't be generated from it.
These earlier forms of FIXML seem to use elements where the modern form
uses attributes.
This converter only understands valid FIXML as of version 4.4 onwards.
The example shown previously is an example of this, and a good way to spot
such messages is to note that the CompIDs are SID
and
TID
attributes of the Hdr
element.
Unfortunately, the FIX Converter doesn't support the older 4.2 style of FIXML.
If you were to add metadata to the FIX.4.2 entry in the Unified FIX Repository, you could generate FIXML schemas in the new 4.4 style (although of course, these wouldn't match the official 4.2 DTD). FIX Converter would then be able to handle this alternative XML representation of FIX.4.2. It would also be necessary to ensure messages didn't directly include repeatingGroups, but instead used componentRefs to components containing repeatingGroups.
Unfortunately, it is common practice to send FIX messages in which the elements are not in the appropriate FIX namespace (or any namespace for that matter). The next two examples break the rules in this way. FIX Converter can cope with this (versioning related constraints below). It always generates FIXML with the right namespace.
http://fixwiki.fixprotocol.org/fixwiki/FPL:FIXML_Syntax
has a couple of FIXML examples, reproduced here.
It shows an example of "FIXML 4.2 Version", which is somewhat verbose.
A good way to spot such messages is that they have a FIXMLMessage
element and the CompIDs are CompID
elements within
Sender
and Target
elements.
The example looks like this :-
<FIXML> <FIXMLMessage> <Header> <PossDupFlag Value="N"/> <PossResend Value="N"/> <SendingTime>20020103-12 00 01</SendingTime> <Sender> <CompID>AFUNDMGR</CompID> </Sender> <Target> <CompID>ABROKER</CompID> </Target> </Header> <ApplicationMessage> <Order> ... stuff </Order> </ApplicationMessage> </FIXMLMessage> </FIXML>
Note that in the example, the SendingTime
should actually
be 2002-01-03T12:00:01
.
The wiki also shows something it calls "FIXML 4.4 Schema Version".
However, in the FIXML 4.4 schema, the CompIDs are not elements
called Sndr
or Tgt
, they are attributes
called SID
and TID
of the Hdr
element.
The example therefore incorrectly looks like this :-
<FIXML> <Order ClOrdID="123456" Side="2" TransactTm="2001-09-11T09:30:47-05:00" OrdTyp="2" Px="93.25" Acct="26522154"> <Hdr Snt="2001-09-11T09:30:47-05:00" PosDup="N" PosRsnd="N" SeqNum="521"> <Sndr ID="AFUNDMGR"/> <Tgt ID="ABROKER"/> </Hdr> <Instrmt Sym="IBM" ID="459200101" IDSrc="1"/> <OrdQty Qty="1000"/> </Order> </FIXML>
Note that even the the fixml-schema-4-4-examples-20040109.zip
file that can be downloaded from the FIX Protocol site include a file
called PositionReportExample1.xml
has this incorrect
Hdr
structure.
I have also seen variants of the above where the sender CompID
element was called Snd
instead of Sndr
.
In fixml-schema-4-4-examples-20040109.zip
the included AllocationInstruction.xml
file has no namespace,
has bad dates, and has the wrong repeating group structure.
As incorrect messages like this don't agree with the FIX Repository, or schemas generated from it, the FIX Converter doesn't support them.
Just as the SWIFT MT (a compact binary format) is transported over the SWIFT network between organisations and SWIFT MT/XML is sometimes transported between applications within an organisation, we can forsee FIX tag=value being spoken between organisations (such as brokers and fund managers) and FIXML being used within these organisations.


Brynna Klamkin-McCarter
Intro to Programming week 3 independent project
brynnacodes
Ping-pong will count up by whole numbers, from 1 to your entered number with the following exceptions:


{% extends "base.html" %} {% block app_content %}
You cancelled your payment.
To make another payment, check your email address for the enrolment button.
Otherwise, return to the home page.


Do you accept the defendant's plan?
View proposed plan
Mary Richards wants to pay the remaining amount by 28 July 2019.
{% else %}| Regular payments of | £100 | |
| Frequency of payments | Monthly | |
| First payment date | 1 month after plan is agreed |
{% extends "layout_task-list.html" %}
{% block page_title %}
Money Claims Prototype
{% endblock %}
{% block home_link %} ../task-list {% endblock %}
{% block proposition_header %}
{% set my_account="1" %}
{% include "includes/propositional_navigation.html" %}
{% endblock %}
{% block content %}
Mary Richards wants to pay the remaining amount by 28 July 2019.
Do you accept the defendant's plan?
View proposed plan
Regular payments of
£100
Frequency of payments
Monthly
First payment date
1 month after plan is agreed


SMF User Help: Logging In and OutIntroduction • Registering • Logging In • Profile • Posting • Personal Message • Searching |
Once you have completed the registration process, you will be able to login to the site for the first time. After that, you can choose whether to stay logged in indefinitely or logout at the end of your visit.
So you might be newly registered or you might simply have been logged out from a previous visit, but there's normally a choice between the login screen and the quick login in either case.
Since this screen (accessed from the Login option of the main menu) is not only where you'll normally be taken on completing registration but also the first thing you'll see in any 'members only' forum, we will describe it first:
While the Username and Password fields should be self-explanatory, Minutes to stay logged in simply means the number of minutes the cookie that keeps you logged in will last before expiring and requiring you to login again. So it's not advisable to enter a long time here if you share a computer and are likely to forget to logout, but you might prefer to check Always stay logged in if no-one else has access to your computer.
Although many forums also have a quick login box to allow you to login direct from any screen, its position on the page may vary considerably from forum to forum. In the SMF default theme, for example, it's in the collapsable section at the top, whereas it's more likely to be at the bottom in themes based on the older YaBB SE forum. If you can't see it and it hasn't simply been collapsed, it's either not enabled at all (in which case you should still be able to access the login screen from the main menu) or you're already logged in (in which case the main menu should include a Logout rather than Login link!).
|
|
To use the quick login box, enter your username and password, select your session length from the drop-down menu and click Login. Please note that Forever, like Always stay logged in, simply means that the computer should remember you until you next choose to logout, and not that you actually need to be online all of that time!
When you have finished browsing the forum, you may decide to logout. Perhaps you share a workstation with someone else, in which case leaving yourself logged in would not be a good idea. So select the Logout option from the main menu and the forum should log you out, turning you into an instant guest, clearing your name from the list of users online and safeguarding your forum identity until you choose to login again.
If you're trying to login to the forum but have forgetten or lost your password, you can retrieve it with the lost password tool by following the Forgot your password? link from the login screen.
You can enter either your username or your email address so long as you check the appropriate option, then click the Send button to send yourself an email containing a link to reset your password. It's also possible to avoid the email altogether if you've set yourself a secret question and answer in your profile, but please beware of questions that anyone could answer or guess (like 'what is the first color of the rainbow?', which would be a very bad choice)!


| summary.mitml {mitml} | R Documentation |
Provides summary statistics and additional information on imputations in objects of class mitml
.
## S3 method for class 'mitml' summary(object, n.Rhat = 3, goodness.of.appr = FALSE, autocorrelation = FALSE, ...)
object |
An object of class |
n.Rhat |
(optional) An integer denoting the number of segments used for calculating the potential scale reduction factor. Default is |
goodness.of.appr |
(optional) A logical flag indicating if the goodness of approximation should be printed. Default is |
autocorrelation |
(optional) A logical flag indicating if the autocorrelation should be printed. Default is |
... |
Not used. |
The summary
method calculates summary statistics for objects of class mitml
as produced by panImpute
or jomoImpute
.
The output includes the potential scale reduction factor (PSRF, or \hat{R}) and (optionally) the goodness of approximation and autocorrelation.
The PSRF is calculated for each parameter of the imputation model and can be used as a convergence diagnostic (Gelman and Rubin, 1992).
Calculation of the PSRFs can be suppressed by setting n.Rhat = NULL
.
The PSRFs are not computed from different chains but by dividing each chain from the imputation phase into a number of segments as denoted by n.Rhat
.
This is slightly different from the original method proposed by Gelman and Rubin.
The goodness of approximation measure indicates what proportion of the posterior standard deviation is due to simulation error.
This is useful for assessing the accuracy of the posterior summaries (e.g., the EAP).
The autocorrelation includes estimates of the autocorrelation in the chains at lag 1 (i.e., for consecutive draws) and for lags k and 2k, where k is the number of iterations between imputations.
For lag k and 2k, the autocorrelation is slightly smoothed to reduce the influence of noise on the estimates (see plot.mitml
).
An object of class summary.mitml
.
A print method is used for more readable output.
Simon Grund
Gelman, A., and Rubin, D. B. (1992). Inference from iterative simulation using multiple sequences. Statistical Science, 7, 457-472.
Hoff, P. D. (2009). A first course in Bayesian statistical methods. New York, NY: Springer.
panImpute
, jomoImpute
, plot.mitml
data(studentratings) fml <- ReadDis + SES ~ ReadAchiev + (1|ID) imp <- panImpute(studentratings, formula = fml, n.burn = 1000, n.iter = 100, m = 5) # print summary summary(imp)


| Package | Description |
|---|---|
| it.unimi.dsi.fastutil.bytes |
Provides type-specific classes for byte elements or keys.
|
| it.unimi.dsi.fastutil.chars |
Provides type-specific classes for character elements or keys.
|
| it.unimi.dsi.fastutil.doubles |
Provides type-specific classes for double elements or keys.
|
| it.unimi.dsi.fastutil.floats |
Provides type-specific classes for float elements or keys.
|
| it.unimi.dsi.fastutil.ints |
Provides type-specific classes for integer elements or keys.
|
| it.unimi.dsi.fastutil.io |
Provides classes and static methods that make object and primitive-type I/O easier and faster.
|
| it.unimi.dsi.fastutil.longs |
Provides type-specific classes for long elements or keys.
|
| it.unimi.dsi.fastutil.objects |
Provides type-specific classes for object elements or keys.
|
| it.unimi.dsi.fastutil.shorts |
Provides type-specific classes for short elements or keys.
|
| Class and Description |
|---|
| AbstractFloatCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractFloatIterator
An abstract class facilitating the creation of type-specific iterators.
|
| FloatCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| FloatIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| FloatIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| Class and Description |
|---|
| AbstractFloatCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractFloatIterator
An abstract class facilitating the creation of type-specific iterators.
|
| FloatCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| FloatIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| FloatIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| Class and Description |
|---|
| AbstractFloatCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractFloatIterator
An abstract class facilitating the creation of type-specific iterators.
|
| FloatCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| FloatIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| FloatIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| Class and Description |
|---|
| AbstractFloat2BooleanFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractFloat2BooleanMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractFloat2BooleanSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractFloat2ByteFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractFloat2ByteMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractFloat2ByteSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractFloat2CharFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractFloat2CharMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractFloat2CharSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractFloat2DoubleFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractFloat2DoubleMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractFloat2DoubleSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractFloat2FloatFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractFloat2FloatMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractFloat2FloatSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractFloat2IntFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractFloat2IntMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractFloat2IntSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractFloat2LongFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractFloat2LongMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractFloat2LongSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractFloat2ObjectFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractFloat2ObjectMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractFloat2ObjectSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractFloat2ReferenceFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractFloat2ReferenceMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractFloat2ReferenceSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractFloat2ShortFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractFloat2ShortMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractFloat2ShortSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractFloatBidirectionalIterator
An abstract class facilitating the creation of type-specific bidirectional iterators.
|
| AbstractFloatBigList
An abstract class providing basic methods for big lists implementing a type-specific big list interface.
|
| AbstractFloatBigListIterator
An abstract class facilitating the creation of type-specific big-list iterators.
|
| AbstractFloatCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractFloatComparator
An abstract class facilitating the creation of type-specific comparators.
|
| AbstractFloatIterator
An abstract class facilitating the creation of type-specific iterators.
|
| AbstractFloatList
An abstract class providing basic methods for lists implementing a type-specific list interface.
|
| AbstractFloatListIterator
An abstract class facilitating the creation of type-specific list iterators.
|
| AbstractFloatPriorityQueue
An abstract class providing basic methods for priority queues implementing a type-specific interface.
|
| AbstractFloatSet
An abstract class providing basic methods for sets implementing a type-specific interface.
|
| AbstractFloatSortedSet
An abstract class providing basic methods for sorted sets implementing a type-specific interface.
|
| Float2BooleanArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Float2BooleanAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Float2BooleanFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2BooleanFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Float2BooleanFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Float2BooleanFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Float2BooleanFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Float2BooleanLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Float2BooleanMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Float2BooleanMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Float2BooleanMap.FastEntrySet
An entry set providing fast iteration.
|
| Float2BooleanMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Float2BooleanMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Float2BooleanMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Float2BooleanMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Float2BooleanOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Float2BooleanOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Float2BooleanRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Float2BooleanSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2BooleanSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Float2BooleanSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Float2ByteArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Float2ByteAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Float2ByteFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2ByteFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Float2ByteFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Float2ByteFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Float2ByteFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Float2ByteLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Float2ByteMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Float2ByteMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Float2ByteMap.FastEntrySet
An entry set providing fast iteration.
|
| Float2ByteMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Float2ByteMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Float2ByteMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Float2ByteMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Float2ByteOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Float2ByteOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Float2ByteRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Float2ByteSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2ByteSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Float2ByteSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Float2CharArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Float2CharAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Float2CharFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2CharFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Float2CharFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Float2CharFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Float2CharFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Float2CharLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Float2CharMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Float2CharMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Float2CharMap.FastEntrySet
An entry set providing fast iteration.
|
| Float2CharMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Float2CharMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Float2CharMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Float2CharMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Float2CharOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Float2CharOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Float2CharRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Float2CharSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2CharSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Float2CharSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Float2DoubleArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Float2DoubleAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Float2DoubleFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2DoubleFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Float2DoubleFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Float2DoubleFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Float2DoubleFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Float2DoubleLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Float2DoubleMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Float2DoubleMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Float2DoubleMap.FastEntrySet
An entry set providing fast iteration.
|
| Float2DoubleMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Float2DoubleMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Float2DoubleMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Float2DoubleMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Float2DoubleOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Float2DoubleOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Float2DoubleRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Float2DoubleSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2DoubleSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Float2DoubleSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Float2FloatArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Float2FloatAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Float2FloatFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2FloatFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Float2FloatFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Float2FloatFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Float2FloatFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Float2FloatLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Float2FloatMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Float2FloatMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Float2FloatMap.FastEntrySet
An entry set providing fast iteration.
|
| Float2FloatMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Float2FloatMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Float2FloatMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Float2FloatMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Float2FloatOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Float2FloatOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Float2FloatRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Float2FloatSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2FloatSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Float2FloatSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Float2IntArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Float2IntAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Float2IntFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2IntFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Float2IntFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Float2IntFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Float2IntFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Float2IntLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Float2IntMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Float2IntMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Float2IntMap.FastEntrySet
An entry set providing fast iteration.
|
| Float2IntMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Float2IntMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Float2IntMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Float2IntMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Float2IntOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Float2IntOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Float2IntRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Float2IntSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2IntSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Float2IntSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Float2LongArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Float2LongAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Float2LongFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2LongFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Float2LongFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Float2LongFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Float2LongFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Float2LongLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Float2LongMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Float2LongMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Float2LongMap.FastEntrySet
An entry set providing fast iteration.
|
| Float2LongMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Float2LongMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Float2LongMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Float2LongMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Float2LongOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Float2LongOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Float2LongRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Float2LongSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2LongSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Float2LongSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Float2ObjectArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Float2ObjectAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Float2ObjectFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2ObjectFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Float2ObjectFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Float2ObjectFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Float2ObjectFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Float2ObjectLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Float2ObjectMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Float2ObjectMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Float2ObjectMap.FastEntrySet
An entry set providing fast iteration.
|
| Float2ObjectMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Float2ObjectMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Float2ObjectMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Float2ObjectMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Float2ObjectOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Float2ObjectOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Float2ObjectRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Float2ObjectSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2ObjectSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Float2ObjectSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Float2ReferenceArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Float2ReferenceAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Float2ReferenceFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2ReferenceFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Float2ReferenceFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Float2ReferenceFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Float2ReferenceFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Float2ReferenceLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Float2ReferenceMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Float2ReferenceMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Float2ReferenceMap.FastEntrySet
An entry set providing fast iteration.
|
| Float2ReferenceMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Float2ReferenceMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Float2ReferenceMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Float2ReferenceMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Float2ReferenceOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Float2ReferenceOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Float2ReferenceRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Float2ReferenceSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2ReferenceSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Float2ReferenceSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Float2ShortArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Float2ShortAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Float2ShortFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2ShortFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Float2ShortFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Float2ShortFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Float2ShortFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Float2ShortLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Float2ShortMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Float2ShortMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Float2ShortMap.FastEntrySet
An entry set providing fast iteration.
|
| Float2ShortMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Float2ShortMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Float2ShortMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Float2ShortMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Float2ShortOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Float2ShortOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Float2ShortRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Float2ShortSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2ShortSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Float2ShortSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| FloatArrayList
A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing.
|
| FloatArrays.Segment |
| FloatArraySet
A simple, brute-force implementation of a set based on a backing array.
|
| FloatBidirectionalIterator
A type-specific bidirectional iterator; provides an additional method to avoid (un)boxing,
and the possibility to skip elements backwards.
|
| FloatBigArrayBigList
A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing.
|
| FloatBigList
A type-specific
BigList ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatBigListIterator
A type-specific
BigListIterator . |
| FloatBigListIterators.EmptyBigListIterator
A class returning no elements and a type-specific big list iterator interface.
|
| FloatBigLists.EmptyBigList
An immutable class representing an empty type-specific big list.
|
| FloatCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| FloatCollections.EmptyCollection
An immutable class representing an empty type-specific collection.
|
| FloatCollections.SynchronizedCollection
A synchronized wrapper class for collections.
|
| FloatCollections.UnmodifiableCollection
An unmodifiable wrapper class for collections.
|
| FloatComparator
A type-specific
Comparator ; provides methods to compare two primitive types both as objects
and as primitive types. |
| FloatHash.Strategy
A type-specific hash strategy.
|
| FloatHeapSemiIndirectPriorityQueue
A type-specific heap-based semi-indirect priority queue.
|
| FloatIndirectPriorityQueue
A type-specific
IndirectPriorityQueue . |
| FloatIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| FloatIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| FloatIterators.EmptyIterator
A class returning no elements and a type-specific iterator interface.
|
| FloatLinkedOpenCustomHashSet
A type-specific linked hash set with with a fast, small-footprint implementation.
|
| FloatLinkedOpenHashSet
A type-specific linked hash set with with a fast, small-footprint implementation.
|
| FloatList
A type-specific
List ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatListIterator
A type-specific bidirectional iterator that is also a
ListIterator . |
| FloatLists.EmptyList
An immutable class representing an empty type-specific list.
|
| FloatLists.SynchronizedList
A synchronized wrapper class for lists.
|
| FloatLists.UnmodifiableList
An unmodifiable wrapper class for lists.
|
| FloatOpenCustomHashSet
A type-specific hash set with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| FloatOpenHashBigSet
A type-specific hash big set with with a fast, small-footprint implementation.
|
| FloatOpenHashSet
A type-specific hash set with with a fast, small-footprint implementation.
|
| FloatPriorityQueue
A type-specific
PriorityQueue ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatSet
A type-specific
Set ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatSets.EmptySet
An immutable class representing the empty set and implementing a type-specific set interface.
|
| FloatSets.Singleton
An immutable class representing a type-specific singleton set.
|
| FloatSets.SynchronizedSet
A synchronized wrapper class for sets.
|
| FloatSets.UnmodifiableSet
An unmodifiable wrapper class for sets.
|
| FloatSortedSet
A type-specific
SortedSet ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatSortedSets.EmptySet
An immutable class representing the empty sorted set and implementing a type-specific set interface.
|
| FloatStack
A type-specific
Stack ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Class and Description |
|---|
| AbstractFloatCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractFloatIterator
An abstract class facilitating the creation of type-specific iterators.
|
| FloatCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| FloatIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| FloatIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| Class and Description |
|---|
| FloatIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| FloatIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| Class and Description |
|---|
| AbstractFloatCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractFloatIterator
An abstract class facilitating the creation of type-specific iterators.
|
| FloatCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| FloatIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| FloatIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| Class and Description |
|---|
| AbstractFloatCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractFloatIterator
An abstract class facilitating the creation of type-specific iterators.
|
| FloatCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| FloatIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| FloatIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| Class and Description |
|---|
| AbstractFloatCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractFloatIterator
An abstract class facilitating the creation of type-specific iterators.
|
| FloatCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| FloatIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| FloatIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
Copyright © 2019. All rights reserved.


Get Stock Details
Enter Your Stock Symbol
Current Time:
{{ ct }}
Full Name of the Company:
{{ fn }}
$Stock Price:
{{ sp }}
Value Changes:
{{ vc }}
Percentage Changes:
{{ pc }}%