Offers an async require.resolve function. It's highly configurable.
# npm
npm install enhanced-resolve
# or Yarn
yarn add enhanced-resolve
The easiest way to create a resolver is to use the createResolver
function on ResolveFactory
, along with one of the supplied File System implementations.
const {
NodeJsInputFileSystem,
CachedInputFileSystem,
ResolverFactory
} = require('enhanced-resolve');
// create a resolver
const myResolver = ResolverFactory.createResolver({
// Typical usage will consume the `NodeJsInputFileSystem` + `CachedInputFileSystem`, which wraps the Node.js `fs` wrapper to add resilience + caching.
fileSystem: new CachedInputFileSystem(new NodeJsInputFileSystem(), 4000),
extensions: ['.js', '.json']
/* any other resolver options here. Options/defaults can be seen below */
});
// resolve a file with the new resolver
const context = {};
const lookupStartPath = '/Users/webpack/some/root/dir';
const request = './path/to-look-up.js';
myResolver.resolve({}, lookupStartPath, request, (err/*Error*/, filepath/*string*/) => {
// Do something with the path
});
For more examples creating different types resolvers (sync/async, context, etc) see lib/node.js
.
| Field | Default | Description |
|---|---|---|
| modules | ["node_modules"] | A list of directories to resolve modules from, can be absolute path or folder name |
| descriptionFiles | ["package.json"] | A list of description files to read from |
| plugins | [] | A list of additional resolve plugins which should be applied |
| mainFields | ["main"] | A list of main fields in description files |
| aliasFields | [] | A list of alias fields in description files |
| mainFiles | ["index"] | A list of main files in directories |
| extensions | [".js", ".json", ".node"] | A list of extensions which should be tried for files |
| enforceExtension | false | Enforce that a extension from extensions must be used |
| moduleExtensions | [] | A list of module extensions which should be tried for modules |
| enforceModuleExtension | false | Enforce that a extension from moduleExtensions must be used |
| alias | [] | A list of module alias configurations or an object which maps key to value |
| resolveToContext | false | Resolve to a context instead of a file |
| unsafeCache | false | Use this cache object to unsafely cache the successful requests |
| cacheWithContext | true | If unsafe cache is enabled, includes request.context in the cache key |
| cachePredicate | function() { return true }; | A function which decides whether a request should be cached or not. An object is passed to the function with path and request properties. |
| fileSystem | The file system which should be used | |
| resolver | undefined | A prepared Resolver to which the plugins are attached |
Similar to webpack
, the core of enhanced-resolve
functionality is implemented as individual plugins that are executed using Tapable
. These plugins can extend the functionality of the library, adding other ways for files/contexts to be resolved.
A plugin should be a class
(or its ES5 equivalent) with an apply
method. The apply
method will receive a resolver
instance, that can be used to hook in to the event system.
class MyResolverPlugin {
constructor(source, target) {
this.source = source;
this.target = target;
}
apply(resolver) {
resolver.plugin(this.source, (request, callback) => {
// Any logic you need to create a new `request` can go here
resolver.doResolve(this.target, request, null, callback);
});
}
}
Plugins are executed in a pipeline, and register which event they should be executed before/after. In the example above, source
is the name of the event that starts the pipeline, and target
is what event this plugin should fire, which is what continues the execution of the pipeline. For an example of how these different plugin events create a chain, see lib/ResolverFactory.js
, in the //// pipeline ////
section.
npm test
If you are using webpack
, and you want to pass custom options to enhanced-resolve
, the options are passed from the resolve
key of your webpack configuration e.g.:
resolve: {
extensions: ['', '.js', '.jsx'],
modules: ['src', 'node_modules'],
plugins: [new DirectoryNamedWebpackPlugin()]
...
},
Copyright (c) 2012-2016 Tobias Koppers
MIT (http://www.opensource.org/licenses/mit-license.php)


GridLayout
places components in a grid.
grid
elements:
columns
- a required element, describes grid columns. It should have either a
count
attribute, or a nested column
element for each column.
In this example, the width of each column, and hence the whole container width, is adjusted by content.
If the container width is explicitly defined in pixels or percents, free space will be divided between the columns equally.
rows
- a required element, contains a set of rows. Each line is defined in its own row
element. row
element should contain elements of the components displayed in the grid's
current row cells. The number of components in a row should not exceed the defined number of columns, but it
can be less.


This index page lists known ShEx tools.
If you are looking for a specific tool, you can consult the list of repositories.


Canvas controllers
Rainbow
Gradient (hex)
Gradient from
Gradient to
Gradient amount
Color sequence
Random
Sequencial
Shapes size
Space between shapes
Opacity from
Opacity to
Timeout speed
Shape
Random
Sequencial
Star
Square
Circle
Triangle


Some “best practices” that you should keep in mind, that would otherwise would cause you problems.
Pacha needs as much permissions as the files it is reading. That is, if you need to watch stuff inside of /root then you would need to have as much permissions as the root user.
We are in constant and heavy development, for the most part, that means that Pacha can make some internal changes that will not be compatible for older versions.
If you have an environment that runs Pacha, have all the instances running the same version. If you are updating, make sure all your instances are updated as well.
Pacha can run with different users with different permission levels. However, we do not encourage using it as a Master with an unpriviliged user. This will cause issues when trying to read files.
We had someone report issues when trying to have a Single instance (Master/Slave in a single server) that would have certain files owned by root that would not be able to push to the unpriviliged user.
It is OK to send me (Alfredo Deza) an email, but do not use it as a fast way to make me help you with your issue. The same goes to a feature request.
I usually find it annoying to receive those kind of emails when there is an Issue Tracker that works as a feature request tracker.
Use it!


Hi there,
Accomplished, versatile bilingual Research & Development Engineer highly regarded for 16 years of experience in semiconductor, biomedical, computer science, and nanotechnology engineering fields. Seasoned in academic research and accustomed to leading projects that produce cutting-edge commercial products. Strong communicator who is able to translate stakeholder requirements into actionable objectives for a skilled team to complete on time and under budget. Academic qualifications include a Doctor of Philosophy in Materials Engineering with a 4.0 GPA from Purdue University.
Education
| Purdue University (2019): | Doctor of Philosophy (PhD) – Materials Engineering (Overall GPA: 4.0/4.0) |
| Auburn University (2020): | Bachelor of Science – Computer Science (Overall GPA: 4.0/4.0) |
| University of Sou. Cal. (2015): | Master of Science – Materials Engineering (Major GPA: 3.9/4.0) |
| Nat'l Cheng Kung U. (2009): | Master of Science – Nanotechnology (Overall GPA: 4.0/4.0) |
| Nat'l Cheng Kung U. (2007): | Bachelor of Science – MSE & CIVIL (Major GPA: 3.8/4.0) |
| Publications (within 4 years) | 20 (a proof for a perfect team player) |


Change dimensions:
Width of vis (px):
Height of vis (px):
Search for:
in
Entire Corpus
Specific newspapers
by
Decade
Year
Month
Search
Sort by:
Relevance: High to Low
Relevance: Low to High
Placeholder 1
Placeholder 2
Default text


_Hilary_and_Jackie_ (R) **** (out of ****)
Hilary (Rachel Griffiths) and Jacqueline (Emily Watson) du Pre are a sisterly pair of child musical prodigies: Hilary on the flute and Jacqueline on the cello. As an adult, Hilary gives up music to live a normal life; Jackie, on the other hand, embarks on a wildly successful career as a concert cellist, winning over worldwide audiences with her flamboyant brand of skill and showmanship. The divergent trajectories of their lives (and not in the way one would expect) and the resulting emotional and physical fallout threatens the sisters' strong bond.
According to the press notes, the fact-based _Hilary_and_Jackie_ was "written and produced as a tribute to Jackie," and, as such, the focus lies squarely on Jackie--and how could it not, with the extraordinary Watson in the role. For me, she is the woman to beat for best actress of the year delivering a stunning performance that captures the entire spectrum of her personality: from sweetness to bitterness, from madness to illness.
But the film is not called _Hilary_and_Jackie_ for nothing, and not just because Griffiths does some terrific--and sure to be underrated--work as the more stable sister. In an ingenious storytelling tactic, director Anand Tucker and screenwriter Frank Cottrell Boyce split the story in three sections, giving clear definition to both sisters. "Hilary and Jackie" details their youth together up until a crucial point where they are separated. "Hilary" focuses on Hilary's quiet life and her ever-shifting feelings about Jackie, who periodically reappears. Finally, there's "Jackie," which picks up at the first section's cutoff point and assumes Jackie's perspective. As we see her turbulent life unfold, her character is given greater dimension, providing vivid reasons for some of Jackie's more erratic behavior in the "Hilary" section (some events from which are retold from Jackie's perspective here). The result is an uncommonly well-rounded portrait of a tormented genius, and a supremely affecting story of real people, only slightly marred by a bit of arbitrary surrealism at the end (which, coincidentally, also marred--moreso--Watson's breakthrough film, 1996's _Breaking_the_Waves_).
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


PEXSI
From ESL
Source authors:
Lin Lin, UC-Berkeley and LBNL, Homepage
Chao Yang, LBNL, Homepage
Responsible for the ESL entry:
License: BSD modified by LBNL
Type of development: external
Download: Project page
The Pole EXpansion and Selected Inversion method PEXSI
is a fast method for evaluating certain selected elements
of a matrix function and can be used for solving the KS-equation without explicit diagonalization.
PEXSI is particularly advantageous for large systems since it reduces the computational effort to
- for 3D systems
- for (quasi-) 2D systems
- for (quasi-) 1D systems
Furthermore it is highly scalable on distributed memory parallel machines.
The Selected Inversion by itself can be used for calculating specific elements of the inverse of a sparse matrix.
Most of the following documentation originates from the PEXSI-homepage.
Contents
Theory
Basics
Given a sparse square matrix and a certain function , the basic idea of PEXSI is to expand using a small number of rational functions (pole expansion)
and to efficiently evaluate by evaluating selected elements (selected inversion).
The currently supported form of includes:
- : Matrix inversion. Since the matrix inversion is already represented as a single term of rational function (pole), no pole expansion is needed. The selected inversion method can be significantly faster than directly inverting the matrix and then extract the selected elements of the inverse.
- : Fermi-Dirac function. This can be used as a "smeared" matrix sign function at , without assuming a spectral gap near . This can be used for evaluating the electron density for electronic structure calculation.
For sparse matrices, the PEXSI method can be more efficient than the widely used diagonalization method for evaluating matrix functions, especially when a relatively large number of eigenpairs are needed to be computed in the diagonalization method.
Application to electronic structure calculations
PEXSI can be used to solve the generalized eigenvalue problem that has to be solved in each SCF-iteration of the KS-DFT formalism without explicit diagonalization. Instead the density matrix is computed directly. Other magnitudes (free energy, atomic forces, local density of states) are given by the same formalism with negligible effort. The PEXSI framework can also be used for calculating the total density of states very efficiently.
With the pole expansion of the Fermi function
the density matrix (in case of a non-orthogonal basis) becomes
The chemical potential has to fulfill
with the total number of electrons and the electron density in real space.
For finding PEXSI implements a hybrid scheme, combining a bisection and a Newton method. This allows determining in a few iterations, even when starting with a wide guess and for difficult cases. Systems with a gap are naturally even easier to solve. If there is a good guess for available, for example from a previous SCF iteration, the bisection can be turned off.
The PEXSI library provides two interfaces. A simple one, finding many of the parameters automatically, and another one offering extensive control of the behavior of the solver.
An extensive description of the implementation of PEXSI in the numerical atomic orbital code SIESTA can be found in [1]
Parallelization
Besides the favorable weak scaling, PEXSI can also scale to large numbers of processors due to its two-level parallelism:
- For accurate evaluation, the pole expansion usually takes 40-60 poles. The calculations on each of these poles are completely independent of each other, enabling an efficient parallelization on this level.
- The calculations on each pole can also be parallelized, with the number of processors that can be used efficiently strongly depending on the problem size, the matrix sparsity, and the sparsity pattern. Typically tens up to thousands of processors per pole are used. An extensive description of the selected inversion and its parallelization can be found in [2]
Large examples need a minimum amount of processors to have enough memory available. Typically this number is much smaller than with dense direct methods like ScaLAPACK.
Authors
Library authors
- Lin Lin, University of California - Berkeley and Lawrence Berkeley National Laboratory, Homepage
- Chao Yang, Lawrence Berkeley National Laboratory, Homepage
Responsible for ESL entry
Publications
- Implementation of PEXSI into SIESTA[1]
- PEXSI [3]
- (Parallel) Selected Inversion [2] [4] [5] [6]
- Pole Expansion [7]
License
PEXSI is distributed under BSD license (modified by Lawrence Berkeley National Laboratory).
Download
A source tarball can be downloaded directly from here.
Installation
Prerequisites
- LAPACK for basic linear algebra operations
- MPI
- SuperLU-Dist (download)
- ParMetis (download) or PT-Scotch (download)
PEXSI requires an external parallel factorization or factorization routine, and an external parallel matrix reordering routine to reduce the fill-in of the factorization routine.
Currently we use SuperLU_DIST for the parallel factorization, and ParMETIS for the parallel fill-in reducing reordering. It is also possible to use PT-Scotch for the reordering. But we recommend to first download ParMETIS.
Instructions
Edit make.inc
Configuration of PEXSI is controlled by a single make.inc file. Examples of the make.inc file are given under the config/ directory.
Find make.inc with the most similar architecture, and copy to the main PEXSI directory (using Edison for example, the latest Intel computer at NERSC). ${PEXSI_DIR} stands for the main directory of PEXSI.
cd ${PEXSI_DIR} cp config/make.inc.edison.intel make.inc
Edit the variables in make.inc
PEXSI_DIR = Main directory for PEXSI DSUPERLU_DIR = Main directory for SuperLU_DIST METIS_DIR = Main directory for METIS PARMETIS_DIR = Main directory for ParMETIS PTSCOTCH_DIR = Main directory for PT-Scotch
Note:
PEXSI can be compiled using debug or release mode in by the variable COMPILE_MODE in make.inc. This variable mainly controls the compiling flag -DRELEASE. The debug mode introduces tracing of call stacks at all levels of functions, and may significantly slow down the code. For production runs, use release mode.
The *.profile configuration files are for debugging purpose and can be ignored.
Build the PEXSI library
If make.inc is configured correctly,
cd ${PEXSI_DIR} cd src make
should produce libpexsi_(suffix).a under src/.
Tests
Build examples
After libpexsi_(suffix).a is built, all driver routines are readily to be compiled. For example, the selected inversion for a complex matrix has the test routine
cd ${PEXSI_DIR} cd examples make driver_pselinv_complex
should produce driver_pselinv_complex, which can be executed with MPI.
For more information on the examples, see Tutorial.
Run tests
After driver_pselinv_complex is compiled,
examples$ mpirun -n 1 ./driver_pselinv_complex
should return the diagonal of the matrix
saved on the 0-th processor, where A is the five-point discretization of a Laplacian operator on a 2D domain. The result can be compared with examples/driver_pselinv_complex.out to check the correctness of the result.
Programming interface
The full documentation of the C/C++ and Fortran interfaces can be found on the project's page:
Further information
The Homepage contains:
- Introduction
- Download
- Installation
- Tutorial
- Core Functionality
- Frequently asked questions
- Troubleshooting
Future developments
- Generalization for k-points
- MPI-OpenMP hybrid version
- Port to Intel MIC
References
- ↑ 1.0 1.1 L. Lin, A. Garcia, G. Huhs and C. Yang, SIESTA-PEXSI: Massively parallel method for efficient and accurate ab initio materials simulation without matrix diagonalization, arXiv
- ↑ 2.0 2.1 M. Jacquelin, L. Lin and C. Yang, PSelInv -- A Distributed Memory Parallel Algorithm for Selected Inversion : the Symmetric Case arXiv
- ↑ L. Lin, M. Chen, C. Yang and L. He, Accelerating atomic orbital-based electronic structure calculation via pole expansion and selected inversion, J. Phys. Condens. Matter 25, 295501, 2013 journal
- ↑ L. Lin, C. Yang, J. Meza, J. Lu, L. Ying and W. E, SelInv -- An algorithm for selected inversion of a sparse symmetric matrix, ACM Trans. Math. Software 37, 40, 2011 journal
- ↑ L. Lin, C. Yang, J. Lu, L. Ying and W. E, A Fast Parallel algorithm for selected inversion of structured sparse matrices with application to 2D electronic structure calculations, SIAM J. Sci. Comput. 33, 1329, 2011 journal
- ↑ L. Lin, J. Lu, L. Ying, R. Car and W. E, Fast algorithm for extracting the diagonal of the inverse matrix with application to the electronic structure analysis of metallic systems, Commun. Math. Sci. 7, 755, 2009 journal
- ↑ L. Lin, J. Lu, L. Ying and W. E, Pole-based approximation of the Fermi-Dirac function, Chin. Ann. Math. 30B, 729, 2009 journal


SIGN UP AS PATIENT
Patient
SIGN UP AS DOCTOR
Doctor
{% include 'includes/_messages.html' %} {% from "includes/_formhelpers.html" import render_field %}
Patient
{{render_field(form1.name, class_="form-control")}}
{{render_field(form1.email, class_="form-control")}}
{{render_field(form1.password, class_="form-control")}}
{{render_field(form1.confirmed, class_="form-control")}}
Register
If already registered,
login here
.
Doctor
{{render_field(form2.docId, class_="form-control")}}
{{render_field(form2.name, class_="form-control")}}
{{render_field(form2.email, class_="form-control")}}
{{render_field(form2.password, class_="form-control")}}
{{render_field(form2.confirmed, class_="form-control")}}
Register
If already registered,
login here
.


/**
* Default sort according to string Unicode code points. This is as specified in [Array.prototype.sort](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort).
* This function is the default sorting function as specified in the [ECMA script](http://www.ecma-international.org/ecma-262/6.0/#sec-sortcompare).
*
* It is provided to all sorting algorithms as a default comparision function which can be overwritten if desired.
*
* @param x The first element to be compared.
* @param y The second element to be compared.
* @return {Number} 0 if both elements are the same, -1 if `x` should have a lower index then `y` and 1 otherwise.
*/
const defaultCompare = ( x, y ) => {
//INFO: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort
//ECMA specification: http://www.ecma-international.org/ecma-262/6.0/#sec-sortcompare
if( x === undefined && y === undefined )
return 0;
if( x === undefined )
return 1;
if( y === undefined )
return -1;
const xString = toString(x);
const yString = toString(y);
if( xString < yString )
return -1;
if( xString > yString )
return 1;
return 0;
};
const toString = obj => {
//ECMA specification: http://www.ecma-international.org/ecma-262/6.0/#sec-tostring
if( obj === null )
return "null";
if( typeof obj === "boolean" || typeof obj === "number" )
return (obj).toString();
if( typeof obj === "string" )
return obj;
if( typeof obj === "symbol" )
throw new TypeError();
//we know we have an object. perhaps return JSON.stringify?
return (obj).toString();
};
module.exports = defaultCompare;


Fins¶
Introduction¶
The module fins
contains functions that can be used to find the
fin-efficiency, and
surface area
of different fin geometries.
The geometries available are:
cylindrical (fin with constant circular cross section)
rectangular (fin with constant rectangular cross section)
rectangularannular (circular fin around a cylindrical shape)
pintriangular (concial fin)
straightparabolic (rectangular base with parabolic cross-section profile)
Note
The formulas for fin efficiency assume an adiabatic fin tip case. If the fin tip is not adiabatic, the appropriate corrected fin length (Lc) must be used for the “length” keyword.
The corrected lengths (Lc) and corrected outer radius (roc) for the different geometries are:
Geometry |
Corrected length |
|---|---|
rectangular |
Lc = L + t/2 (L = physical length, t = thickness, Lc = corrected length) |
cylindrical |
Lc = L + D/4 (L = physical length, D = diameter, , Lc = corrected length) |
rectangularannular |
roc = ro + t/2 (ro = outer radius, t = thickness, , roc = corrected outer radius) |
pintriangular |
Lc = L (no change, L = physical length, Lc = corrected length) |
straightparabolic |
Lc = L (no change, L = physical length, Lc = corrected length) |
How to use
It is recommended that the module be imported
as from pychemengg import fins as fins
The following examples demonstrate how the module fins
can be used to solve heat transfer problems.
Examples¶
Example 1: Fins cylindrical, single fin
¶
Example 1.
A rod of diameter D = 2 cm, length= 25 cm, and thermal
conductivity k = 50 W/mC is exposed to ambient temperature air at
Tinfinity = 20 C with a heat transfer coefficient h = 64 W/m2C.
If one end of the rod is maintained at 120 C, find the heat loss from the
rod. Ans: heat loss = 25.1 kW
# EXAMPLE 1 from pychemengg.heattransfer import fins as fins # The rod is similar to a single fin. # Model it as a cylindrical fin. # The rod tip is assumed to be adiabatic, so length = actual length. rod = fins.Fin(length=25e-2, diameter=2e-2, heattransfercoefficient=64, thermalconductivity=50) # There are other parameters for the 'Fin' class, however, only the relevant ones # need to be provided. The rest can be left as 'None' by default. # Next call on the cylindrical method to get efficiency and surface area. rod.cylindrical() # The above method will run and create attributes 'efficiency' and 'surfacearea'. max_heatrate = rod.heattransfercoefficient * rod.surfacearea * (120-20) actual_heatrate = max_heatrate * rod.efficiency print(f"Heat loss = {actual_heatrate: 0.1f} W") # PRINTED OUTPUT Heat loss = 25.1 W
Example 2: Fins rectangular annular, many fins
¶
Example 2.
Annular fins with inner radius of 12.5 mm, outer radius of 22.5 mm and thickness
of 1 mm are attached to a cylinder at 200 fins per meter. The cylinder surface is
maintained at 250°C. The surrounding air temperature is 25°C. Consider the convective
heat transfer coefficient (h) as 25 W/m2K and the thermal conductivity (k) of the fin
as 240 W/mK.
Find heat loss per fin.
Ans: heat loss = 13 W
Heat loss per unit length of cylinder.
Ans: heat loss = 2961 W/m
# EXAMPLE 2 from pychemengg.heattransfer import fins as fins # Model fin as a rectangularannular fin. # The fin tip is not given to be adiabatic. # So outer radius should be corrected as correctedradius = outerfinradius + thickness/2 correctedouter_radius = 22.5e-3 + 1e-3/2 annularfin = fins.Fin(inner_radius=12.5e-3, outer_radius=correctedouter_radius, thickness=1e-3, heattransfercoefficient=25, thermalconductivity=240) # There are other parameters for the 'Fin' class, however, only the relevant ones # need to be provided. The rest can be left as 'None' by default. # Even if irrelevant ones are provided, the method only uses the relavant parameters. # Next call on the rectangularannular method to get efficiency and surface area. annularfin.rectangularannular() # The above method will run and create attributes 'efficiency' and 'surfacearea'. max_heatrateperfin = annularfin.heattransfercoefficient * annularfin.surfacearea * (250-25) actualheatrateperfin = max_heatrateperfin * annularfin.efficiency print(f"Heat loss from single fin = {actualheatrateperfin: 0.1f} W") # To compute heat loss from 1 m long finned cylinder # Total heat loss from 1m cylinder = heat loss from fins on 1m + heat loss from surface not covered by fins fincount=200 total_finheatloss = fincount * actualheatrateperfin import math barecylindersurfacearea = math.pi * (12.5e-3 * 2) * 1 # area = pi * D * L baseareaof_singlefin = math.pi * (12.5e-3 *2) * 1e-3 # here L = 1e-3 areacoveredby_allfins = 200 * baseareaof_singlefin heatlossfrom_area_without_fins = 25 * (barecylindersurfacearea-areacoveredby_allfins) * (250-25) totalheatloss = total_finheatloss + heatlossfrom_area_without_fins print(f"Heat loss for 1 m cylinder = {totalheatloss: 0.0f} W/m") # PRINTED OUTPUT Heat loss from single fin = 13.0 W Heat loss for 1 m cylinder = 2961 W/m


{% extends "base.html" %} {% block content %}
Pardon My Dragons is being created as we speak by Sebastian G. Sweet. This application was designed to help people plan their Dungeons and Dragons characters, level ups, and encounters. This application is being developed for 5th Edition D&D, with no plan to expand to further editions yet.


Symbol Index for "Outcome of Property"
Symbol Index for diagram
"Outcome of Property"
Causal Relation (Class)
CR/Association (Generalization Node)
Outcome Of Activity (Class)
Outcome Of Incident (Class)
Outcome of Property (Class)
source of (Association)
Subject Property (Class)


FullStack Web Developer
My name is Jeffrey Klein, I am originally from Gresham, Oregon and moved down to New mexico last year. I am an avid reader, enjoy making models, and gaming when I have the time. I was exposed to the FullStack boot camp course in late february and found it exciting after reading up on what the boot camp was all about. I decided to take the boot camp and it's one of the best decisions of my life. I met many great people during my time in the course. I am a FullStack Web Developer working in both the front-end and back-end development. I have an understanding in HTML5, JavaScript, CSS3, BootStrap, React, React BootStrap, MYSQL, Docker, Docker Compose, and Express. I attended the CNM Ingenuity Deep dive Boot camp from April to June of 2020. Due to Covid-19, my class was entirely done virtually through zoom and so, I have experience working remotely. I have also been using Github daily throughout the boot camp and have become comfortable using it. Below, I have some of the projects I have worked on in class.
The CSS Challenge was the first project I did during the boot camp. The purpose of the challenge was to create a stylesheet and link it to the HTML file. Once it was linked to the HTML, we had a mock image of what the end goal was. This challenge was a good way to get me immersed into the ways of using CSS to change my flat HTML file.
The JavaScript Events Challenge had me work on using JavaScript to make functions that on a click of a button or in my case the paragraph change either the color or font of the paragraph text or replace a word with another word within the paragraph. In this project, I primarily used HTML and JavaScript.
The Bootstrap Challenge was the second challenge that I did during the boot camp. During this challenge, the goal was to make the web page mobile responsive while also adding in some HTML and CSS. This challenge allowed for some creative changes using CSS such as making the images rounded and playing with some native bootstrap styling such as the jumbotron.


Edit text below
This is an example of a simple headline or text with rounded corners using
a gooey SVG filter.


About Us
A paragraph about us
more
more para
Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat.
Ut wisi enim ad minim veniam, quis nostrud exerci tation ullamcorper suscipit lobortis nisl ut aliquip ex ea commodo consequat.
Duis autem vel eum iriure dolor in hendrerit in vulputate velit esse molestie consequat, vel illum dolore eu feugiat nulla facilisis at vero eros
et accumsan et iusto odio dignissim qui blandit praesent luptatum zzril delenit augue duis dolore te feugait nulla facilisi.
Highlight points
Highlight points
Mirum est notare quam littera gothica, quam nunc putamus parum claram, anteposuerit litterarum formas humanitatis per seacula quarta decima et quinta decima.
Your creative
branding partners.
Brandesign is Bangalore’s upcoming premier creative design agency aiming to provide world-class design with millennial minds for this modern era.Through solid strategic direction and inspiring creative execution, we build strong , robust brands, delivering unique and powerful identities that claim distinction and resonate in the marketplace.
Targeted campaigns to
build and mark your brand online.
At Brandesign, our digital media services are customised to meet the needs of our clients regardless of industry. Our campaigns are well thought out, strategically targeted, and always delivered with a focus on premium
quality and brand consistency.
Flexible packages to
suit every business.
Whether you’re a new startup looking to enter the market with a bank, or an established business in need of a refresh, our team of experienced brand specialists can cater to you as per your needs.No matter your industry, location, business size or budget, we offer flexible and affordable branding packages.
Slick. Seamless.
Responsive Websites.
From simple landing pages and one page micro sites to comprehensive, multi-page mega sites, we offer web design and development, guaranteed to produce seamless, engaging and enjoyable web experience.


THE LIVING MUSEUM A film review by Steve Rhodes Copyright 1999 Steve Rhodes RATING (0 TO ****): * 1/2
A mental institution as a fertile environment for creating modern art? The artwork in THE LIVING MUSEUM argues convincing that mental instability and impressive art can go hand in hand.
The museum director of "The Living Museum," located within the Creedmoor Psychiatric Center in Queens, New York, reasons that, because there are no rules there, it provides a rich breeding ground for the development of art. He compares the artistic results favorably with pieces on display in prestigious galleries like the Whitney. Based on this untrained eye, he's right.
Even if the art is striking, the documentary by previous Oscar winner Jessica Yu (BREATHING LESSONS: THE LIFE AND WORK OF MARK O'BRIEN) isn't. She divides the movie into chapters with one for each patient/artist, but the interviewees all speak in dull monotones. The museum director and psychologist, Dr. Janos Marton is the most soporific of all.
The intent is always clear. The Dr. Marton sees the patients, who range from mildly ill outpatients to quite sick inpatients, as being helped by creating art, which is a form of therapy. He brags that his artists are free of the pretensions normally found in the art world. He believes that psychotic breakdowns free the mind to artistic possibilities and that the act of painting provides catharsis.
THE LIVING MUSEUM is the sort of good intentioned film that critics don't like to criticize. It's easier to offer a few meaningless platitudes and be done with it. As much as I enjoyed the three Jessica Yu short films I've seen before this one, THE LIVING MUSEUM is never compelling. The art it displays is interesting, but the interviews aren't. The people are all slightly quirky, as you would expect, but they drone so much that I never felt involved. Perhaps as a tightly edited short, it would have worked, but as a feature length movie, it is dreadfully dull.
THE LIVING MUSEUM runs 1:20. It is not rated but would be PG for brief nudity and some sexuality and would be fine for kids old enough to be interested.
Email<EMAIL_ADDRESS>Web: www.InternetReviews.com
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Maestro Reorin:
Garrr! Go away, boy, and stop bothering me!
(Only characters level 75 and above are permitted to take on this quest.)


Cop who arrested, released Bruce McArthur pleads not guilty to disciplinary charges
by The Canadian Press, StaffTORONTO - A Toronto police officer involved in the 2016 arrest and release of serial killer Bruce McArthur has pleaded not guilty to disciplinary charges.
Lawyer Lawrence Gridin entered the plea this morning on behalf of Sgt. Paul Gauthier during a brief appearance before the Toronto police tribunal.
Gauthier is charged with insubordination and neglect of duty related to his handling of a complaint by a man who alleged McArthur tried to strangle him.
The officer was not present Wednesday. He has yet to appear before the tribunal, with his lawyer citing an undisclosed illness.
Gridin has said his client will be at the hearing to face the accusations against him when the time comes.
A notice of hearing released earlier this year alleges Gauthier did not record a video statement from the complainant or photograph his injuries within 72 hours, as required by the force's policy on domestic violence investigations.


Game Winner James Doyle Dedicates St Mullins Win To Team's Selector
by Gary ConnaughtonCarlow champions St Mullins have secured passage to the Leinster final, coming away with the win over Rathdowney-Errill in the most dramatic circumstances.
It was a cracking game of hurling, contested between two good sides. It was nip and tuck throughout, with the result ultimately being decided in injury time.
Paddy Purcell got the opening goal of the game, showing great skill to bounce the ball off the ground and bury it beyond the opposition goalkeeper.
St Mullins would reply straight away, going right up the other end of the pitch to raise a green flag of their own.
They would get their second goal of the game five minutes before the interval.
The teams would trade scores throughout the second period, with the two sides deadlocked as the clock ticked over to 60 minutes thanks to this James Doyle point.
The same player would then come up with the moment of brilliance to decide the game, flicking the ball over an opposition defender and notching the winning point.
Speaking after the game Doyle dedicated the win to to team selector Michael Ryan, who took ill during the big win over Cuala in the last round.
I'd say he's a happy man now! To be honest with you, this is all for him. He's a great club man and I'd say he's delighted up there now In Dublin.
This is definitely all for him.
St Mullins have now booked their first ever provincial final place, becoming only the second Carlow team to reach a Leinster decider. They will face reigning All-Ireland champions Ballyhale Shamrocks who will no doubt be strong favourites.
The Carlow club have already upset the odds once in this championship, defeating the Dublin champions in the quarter final. They will be hoping they have one more upset in them.


My Photos
Currently
photos.
The operator of this server has not provided a license for their files.
Made with ♥ by
znepb
- Hosted by me - ⭐ this on GitHub


Plugin Information |
|---|
View Skype notifier on the plugin site for more information. |
Integrates Jenkins with Skype for instant messaging. Requires extra manual installation steps!!!
Note that you also need to install the instant-messaging plugin.
This plugin enables Jenkins to send build notifications via Skype, and to talk to Jenkins via a 'bot' to run commands, query build status etc..
Installation Requirements
Follow the steps below
This plugin needs the Instant Messaging Plugin. Please ensure that the latest version of this plug-in is also installed.This plugin requires special hudson setup to work.
How to get it running
This plugin requires a running skype and uses JNI so it will take some configuration to work. Currently tested on Windows Server 2003 and CentOS 5.5
- Skype must be running as the same user as a hudson slave/master
- If running hudson on a 64bit JDK you must add a windows/linux slave running on a 32bit jdk
- The slave must have a "skype" label
- Check the logs to see if it connects ok to skype
- If it connects ok, then you must allow the java plugin to connect with skype
- Add skypeid to all users in hudson
- Good luck
Notes
The libskype.so is build for CentOS 5.5
I used the static version of skype, but I guess other versions will work also.If you run the slave/master as a windows service it will fail to connect with skype
Node startup script for linux
Must either have a running console or use vncserver on display :1 (logon to the vnc/console to accepts the jenkins plugin in skype)
Also copy the skype executable to the slave home folder
export JAVA_HOME=/usr/java/32bit/jdk1.6.0_24 export DISPLAY=:1 killall skype killall $JAVA_HOME/bin/java /usr/bin/skype.sh& cd /work/skypeslave name=$(hostname -f) wget -N -nd --progress=dot:mega http://${name}:8080/jnlpJars/slave.jar $JAVA_HOME/bin/java -jar /work/skypeslave/slave.jar -jnlpUrl http://${name}/computer/skype/slave-agent.jnlp
Skype on CentOS
http://wiki.centos.org/HowTos/Skype
http://punkts.org/trac/wiki/Skype22ForCentOS5
ChangeLog
Version 1.1 (May 14, 2011)
- Bot commands are now supported.
- Groups are now supported, prefix groups with a *


Licence conditions
When you get this licence you agree that:
- the licence will only be used by the person named on it
- you will carry the necessary proof of your licence when you go fishing and show it to our bailiffs if they ask
- the licence gives you the right to use a fishing rod and line only - not the right to fish. You will check you have permission from any owner of fishing rights before you fish
- you will read and comply with the freshwater rod fishing rules
- you will only use the licence while it is valid


| Book id | Bookname | Category | Author | Publisher | Pubdate | Price buying | Price selling |
|---|---|---|---|---|---|---|---|
| {{record[0]}} | {{record[1]}} | {{record[2]}} | {{record[3]}} | {{record[4]}} | {{record[5]}} | {{record[6]}} | {{record[7]}} |
| Book id | Bookname | Category | Author | Publisher | Pubdate | Price buying | Price selling |
|---|---|---|---|---|---|---|---|
| {{record[0]}} | {{record[1]}} | {{record[2]}} | {{record[3]}} | {{record[4]}} | {{record[5]}} | {{record[6]}} | {{record[7]}} |


We have received your request to go live
We'll get back to you regarding approval in the next working day. Once approved you'll need to activate the service in the admin tool.
We'll get back to you regarding approval in the next working day. Once approved you'll need to activate the service in the admin tool.


 It is the first corporate children's hospital in India, started on 14th November 1999 on Children's Day. Setting the benchmark in neonatal and paediatric intensive care, Rainbow has played a major role in saving thousands of critically ill children and has emerged as one of the best children’s hospital in the country. Rainbow Hospitals aims to provide high standards of care for the mother, women, fetus, newborn and children so that none of them is deprived of a tertiary care facility. The hospital's clinical staffs include strong team of highly qualified and experienced Consultants, dynamic team of residents and fellows, well trained nurses and paramedical personnel, and highly motivated team of full- and part-time employees. The measure of our success is in the number of smiling faces. We are here because we care for you. Filling your life with the pinkest of health is our dream. As a Women and Children’s Hospital, Rainbow strives to send you home in perfect health as a colourful life welcomes you back.
We were also awarded “Best Children's Hospital in the country” by” CNBC, TV 18, ICICI Lombard at India Health Care Awards” in 2010. We were ranked among the “Five Best Children's hospitals in India”by 'The Week' and ‘HANSA Research’ for the year 2010, 2011 and 2012.
Rainbow Hospitals also received the “Six Sigma Healthcare Excellence Award” at the first Asia Pacific International Conference held at Mt. Abu, Rajasthan during 4th and 5th of October 2013.


Personal Information
- Full Name
- João Pedro Pereira da Costa Portela
- City of Residence
- Porto, Portugal (Remote)
- Nationality
- Portuguese
- Mission
- Build well designed software, that make people's lives easier and more enjoyable.
- Technical Skills (Expert)
- JavaScript, TypeScript, NodeJS, React, Redux, Electron, MongoDB
- Technical Skills (Familiar)
- Golang, Rust, C++, HTML, CSS, Java, C, C#, PHP, SQL, Ruby, Python, CFML, Web APIs, Android, Rails, OpenGL, Less, Redis, RabbitMQ
Work Experience
- Position
- Senior Engineer
- Dates
- July 2015 - now
- Main activities
-
- Part of the team that created InVision Studio (Data, SVG and Sketch import, Publishing, Foundational work)
- Development of the Studio Platform (Plugin ecossystem) and Studio Runtime (frontend architecture framework)
- Development of Motion (which pivoted into Studio)
- Implementation of several features, bug fixes and performance improvements for the InVision main application (Slack API integration, Activity feed)
- Technologies
- JavaScript, TypeScript, NodeJS, Electron, SVG, Canvas, Golang, Redis, MongoDB, RabbitMQ, Docker, CFML, AWS (S3, SNS, SQS)
- Employer
- InVision
- Position
- Senior Developer
- Dates
- August 2014 - July 2015
- Main activities
-
Tech Lead on the Broadwand project, on a technical team with 2 members.
Responsible for designing the architecture and the implementation of 7 micro-services, 2 Android apps and 1 Firefox add-on.
- Technologies
- JavaScript, NodeJS, Redis, MongoDB, Firefox Addon SDK, Android
- Employer
- Imaginary Cloud
- Position
- Front-End Developer
- Dates
- September 2012 - August 2014
- Main activities
-
Development of the frontend layer of the Betfair Sportsbook, having been involved on it since the first day of its inception.
Tech Lead for the Google Analytics project and a member of the Frontend Architecture Group.
- Technologies
- HTML, CSS, JavaScript, YUI, Less, Jasmine
- Employer
- Blip / Betfair
- Position
- Freelance Web Developer
- Dates
- May 2013 - December 2013 (Part-time)
- Main activities
-
Worked on the frontend of four web pages, by implementing responsive, cross-platform and cross-device layouts.
- Technologies
- HTML, CSS, JavaScript, jQuery, Photoshop, PHP
- Employer
- Waynext
- Position
- Google Summer of Code - Student
- Dates
- May 2009/2010/2011 - August 2009/2010/2011
- Main activities
-
Participated in three editions of Google Summer of Code as a student. Successfully completed all three web development projects.
- Technologies
- HTML, CSS, JavaScript, Java, Spring, Perl
- Employer
- Google / OpenMRS / Dreamwidth
Education
- Dates
- September 2007 - July 2012
- Title of Qualification
- Master in Informatics and Computer Engineering (B.Sc. + M.Sc.)
- Principal Subjects
- Software Engineering, Programming, Mobile Computing, Database Design, Systems Design, Project Management, Artificial Intelligence, Web Development, Computer Architecture, Operating Systems
- Main activities
-
- Thesis: Multi-touch Interaction for Interface Prototyping (Grade: 19/20).
- Researcher: 6 months grant on applying natural user interfaces to collaborative 3d urban environments (C#/XNA).
- Team Leader: of 8 members, in an academic project done for a real company (iTds).
- NIFEUP Member: Software developer for a classifieds portal for the FEUP community (Ruby on Rails).
- Organization Name
- Faculty of Engineering of the University of Porto (FEUP)
- Grade Point Average
- 17 out of 20
Personal skills
- Language skills
- Native Portuguese, Fluent English, Basic French, Spanish, Japanese
- Social skills
-
- Passionate for developing team processes, lean methodologies, business development and user centered design, by experience and self-learning.
- Ability to work in teams and under pressure, through tight deadlines, while maintaining optimism and a good vibe around the team.
- Experience in mentoring junior developers, code reviews and dealing with stakeholders from different backgrounds.
- Strong sense of responsibility, accountability and proactivity, by having worked directly with clients.
- Certifications
- FCE - First Certificate in English (Grade A, C1)
- Certified Scrum Master - Scrum Alliance
- Artistic skills
- Formal classical training on Piano, Violin, Musical Formation and Choir.
- Driving Licences
- B, B1


See: Description
| Interface | Description |
|---|---|
| Float2BooleanFunction |
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| 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.
|
| 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.
|
| Float2ByteFunction |
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| 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.
|
| 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.
|
| Float2CharFunction |
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| 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.
|
| 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.
|
| Float2DoubleFunction |
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| 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.
|
| 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.
|
| Float2FloatFunction |
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| 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.
|
| 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.
|
| Float2IntFunction |
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| 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.
|
| 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.
|
| Float2LongFunction |
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| 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.
|
| 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.
|
| Float2ObjectFunction<V> |
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2ObjectMap<V> |
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Float2ObjectMap.Entry<V> |
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Float2ObjectMap.FastEntrySet<V> |
An entry set providing fast iteration.
|
| Float2ObjectSortedMap<V> |
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2ObjectSortedMap.FastSortedEntrySet<V> |
A sorted entry set providing fast iteration.
|
| Float2ReferenceFunction<V> |
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2ReferenceMap<V> |
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Float2ReferenceMap.Entry<V> |
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Float2ReferenceMap.FastEntrySet<V> |
An entry set providing fast iteration.
|
| Float2ReferenceSortedMap<V> |
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Float2ReferenceSortedMap.FastSortedEntrySet<V> |
A sorted entry set providing fast iteration.
|
| Float2ShortFunction |
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| 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.
|
| 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.
|
| FloatBidirectionalIterator |
A type-specific bidirectional iterator; provides an additional method to avoid (un)boxing,
and the possibility to skip elements backwards.
|
| FloatBigList |
A type-specific
BigList ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatBigListIterator |
A type-specific
BigListIterator . |
| FloatCollection |
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| FloatComparator |
A type-specific
Comparator ; provides methods to compare two primitive types both as objects
and as primitive types. |
| FloatHash |
A type-specific
Hash interface. |
| FloatHash.Strategy |
A type-specific hash strategy.
|
| 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. |
| 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 . |
| 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. |
| FloatSortedSet |
A type-specific
SortedSet ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| FloatStack |
A type-specific
Stack ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Class | 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.
|
| AbstractFloat2BooleanMap.BasicEntry |
This class provides a basic but complete type-specific entry class for all those maps implementations
that do not have entries on their own (e.g., most immutable maps).
|
| AbstractFloat2BooleanSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractFloat2BooleanSortedMap.KeySetIterator |
A wrapper exhibiting a map iterator as an iterator on keys.
|
| AbstractFloat2BooleanSortedMap.ValuesIterator |
A wrapper exhibiting a map iterator as an iterator on values.
|
| 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.
|
| AbstractFloat2ByteMap.BasicEntry |
This class provides a basic but complete type-specific entry class for all those maps implementations
that do not have entries on their own (e.g., most immutable maps).
|
| AbstractFloat2ByteSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractFloat2ByteSortedMap.KeySetIterator |
A wrapper exhibiting a map iterator as an iterator on keys.
|
| AbstractFloat2ByteSortedMap.ValuesIterator |
A wrapper exhibiting a map iterator as an iterator on values.
|
| 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.
|
| AbstractFloat2CharMap.BasicEntry |
This class provides a basic but complete type-specific entry class for all those maps implementations
that do not have entries on their own (e.g., most immutable maps).
|
| AbstractFloat2CharSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractFloat2CharSortedMap.KeySetIterator |
A wrapper exhibiting a map iterator as an iterator on keys.
|
| AbstractFloat2CharSortedMap.ValuesIterator |
A wrapper exhibiting a map iterator as an iterator on values.
|
| 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.
|
| AbstractFloat2DoubleMap.BasicEntry |
This class provides a basic but complete type-specific entry class for all those maps implementations
that do not have entries on their own (e.g., most immutable maps).
|
| AbstractFloat2DoubleSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractFloat2DoubleSortedMap.KeySetIterator |
A wrapper exhibiting a map iterator as an iterator on keys.
|
| AbstractFloat2DoubleSortedMap.ValuesIterator |
A wrapper exhibiting a map iterator as an iterator on values.
|
| 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.
|
| AbstractFloat2FloatMap.BasicEntry |
This class provides a basic but complete type-specific entry class for all those maps implementations
that do not have entries on their own (e.g., most immutable maps).
|
| AbstractFloat2FloatSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractFloat2FloatSortedMap.KeySetIterator |
A wrapper exhibiting a map iterator as an iterator on keys.
|
| AbstractFloat2FloatSortedMap.ValuesIterator |
A wrapper exhibiting a map iterator as an iterator on values.
|
| 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.
|
| AbstractFloat2IntMap.BasicEntry |
This class provides a basic but complete type-specific entry class for all those maps implementations
that do not have entries on their own (e.g., most immutable maps).
|
| AbstractFloat2IntSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractFloat2IntSortedMap.KeySetIterator |
A wrapper exhibiting a map iterator as an iterator on keys.
|
| AbstractFloat2IntSortedMap.ValuesIterator |
A wrapper exhibiting a map iterator as an iterator on values.
|
| 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.
|
| AbstractFloat2LongMap.BasicEntry |
This class provides a basic but complete type-specific entry class for all those maps implementations
that do not have entries on their own (e.g., most immutable maps).
|
| AbstractFloat2LongSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractFloat2LongSortedMap.KeySetIterator |
A wrapper exhibiting a map iterator as an iterator on keys.
|
| AbstractFloat2LongSortedMap.ValuesIterator |
A wrapper exhibiting a map iterator as an iterator on values.
|
| AbstractFloat2ObjectFunction<V> |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractFloat2ObjectMap<V> |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractFloat2ObjectMap.BasicEntry<V> |
This class provides a basic but complete type-specific entry class for all those maps implementations
that do not have entries on their own (e.g., most immutable maps).
|
| AbstractFloat2ObjectSortedMap<V> |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractFloat2ObjectSortedMap.KeySetIterator<V> |
A wrapper exhibiting a map iterator as an iterator on keys.
|
| AbstractFloat2ObjectSortedMap.ValuesIterator<V> |
A wrapper exhibiting a map iterator as an iterator on values.
|
| AbstractFloat2ReferenceFunction<V> |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractFloat2ReferenceMap<V> |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractFloat2ReferenceMap.BasicEntry<V> |
This class provides a basic but complete type-specific entry class for all those maps implementations
that do not have entries on their own (e.g., most immutable maps).
|
| AbstractFloat2ReferenceSortedMap<V> |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractFloat2ReferenceSortedMap.KeySetIterator<V> |
A wrapper exhibiting a map iterator as an iterator on keys.
|
| AbstractFloat2ReferenceSortedMap.ValuesIterator<V> |
A wrapper exhibiting a map iterator as an iterator on values.
|
| 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.
|
| AbstractFloat2ShortMap.BasicEntry |
This class provides a basic but complete type-specific entry class for all those maps implementations
that do not have entries on their own (e.g., most immutable maps).
|
| AbstractFloat2ShortSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractFloat2ShortSortedMap.KeySetIterator |
A wrapper exhibiting a map iterator as an iterator on keys.
|
| AbstractFloat2ShortSortedMap.ValuesIterator |
A wrapper exhibiting a map iterator as an iterator on values.
|
| 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.
|
| AbstractFloatBigList.FloatSubList |
A class implementing a sublist view.
|
| 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.
|
| AbstractFloatList.FloatSubList |
A class implementing a sublist view.
|
| 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.
|
| AbstractFloatStack |
An abstract class providing basic methods for implementing a type-specific stack 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.
|
| Float2BooleanFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| 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.
|
| Float2BooleanMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| 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.
|
| Float2BooleanSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Float2BooleanSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Float2BooleanSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Float2BooleanSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Float2BooleanSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| 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.
|
| Float2ByteFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| 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.
|
| Float2ByteMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| 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.
|
| Float2ByteSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Float2ByteSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Float2ByteSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Float2ByteSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Float2ByteSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| 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.
|
| Float2CharFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| 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.
|
| Float2CharMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| 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.
|
| Float2CharSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Float2CharSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Float2CharSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Float2CharSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Float2CharSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| 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.
|
| Float2DoubleFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| 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.
|
| Float2DoubleMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| 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.
|
| Float2DoubleSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Float2DoubleSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Float2DoubleSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Float2DoubleSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Float2DoubleSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| 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.
|
| Float2FloatFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| 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.
|
| Float2FloatMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| 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.
|
| Float2FloatSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Float2FloatSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Float2FloatSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Float2FloatSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Float2FloatSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| 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.
|
| Float2IntFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| 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.
|
| Float2IntMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| 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.
|
| Float2IntSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Float2IntSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Float2IntSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Float2IntSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Float2IntSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| 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.
|
| Float2LongFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| 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.
|
| Float2LongMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| 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.
|
| Float2LongSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Float2LongSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Float2LongSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Float2LongSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Float2LongSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Float2ObjectArrayMap<V> |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Float2ObjectAVLTreeMap<V> |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Float2ObjectFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Float2ObjectFunctions.EmptyFunction<V> |
An immutable class representing an empty type-specific function.
|
| Float2ObjectFunctions.Singleton<V> |
An immutable class representing a type-specific singleton function.
|
| Float2ObjectFunctions.SynchronizedFunction<V> |
A synchronized wrapper class for functions.
|
| Float2ObjectFunctions.UnmodifiableFunction<V> |
An unmodifiable wrapper class for functions.
|
| Float2ObjectLinkedOpenHashMap<V> |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Float2ObjectMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Float2ObjectMaps.EmptyMap<V> |
An immutable class representing an empty type-specific map.
|
| Float2ObjectMaps.Singleton<V> |
An immutable class representing a type-specific singleton map.
|
| Float2ObjectMaps.SynchronizedMap<V> |
A synchronized wrapper class for maps.
|
| Float2ObjectMaps.UnmodifiableMap<V> |
An unmodifiable wrapper class for maps.
|
| Float2ObjectOpenCustomHashMap<V> |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Float2ObjectOpenHashMap<V> |
A type-specific hash map with a fast, small-footprint implementation.
|
| Float2ObjectRBTreeMap<V> |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Float2ObjectSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Float2ObjectSortedMaps.EmptySortedMap<V> |
An immutable class representing an empty type-specific sorted map.
|
| Float2ObjectSortedMaps.Singleton<V> |
An immutable class representing a type-specific singleton sorted map.
|
| Float2ObjectSortedMaps.SynchronizedSortedMap<V> |
A synchronized wrapper class for sorted maps.
|
| Float2ObjectSortedMaps.UnmodifiableSortedMap<V> |
An unmodifiable wrapper class for sorted maps.
|
| Float2ReferenceArrayMap<V> |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Float2ReferenceAVLTreeMap<V> |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Float2ReferenceFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Float2ReferenceFunctions.EmptyFunction<V> |
An immutable class representing an empty type-specific function.
|
| Float2ReferenceFunctions.Singleton<V> |
An immutable class representing a type-specific singleton function.
|
| Float2ReferenceFunctions.SynchronizedFunction<V> |
A synchronized wrapper class for functions.
|
| Float2ReferenceFunctions.UnmodifiableFunction<V> |
An unmodifiable wrapper class for functions.
|
| Float2ReferenceLinkedOpenHashMap<V> |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Float2ReferenceMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Float2ReferenceMaps.EmptyMap<V> |
An immutable class representing an empty type-specific map.
|
| Float2ReferenceMaps.Singleton<V> |
An immutable class representing a type-specific singleton map.
|
| Float2ReferenceMaps.SynchronizedMap<V> |
A synchronized wrapper class for maps.
|
| Float2ReferenceMaps.UnmodifiableMap<V> |
An unmodifiable wrapper class for maps.
|
| Float2ReferenceOpenCustomHashMap<V> |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Float2ReferenceOpenHashMap<V> |
A type-specific hash map with a fast, small-footprint implementation.
|
| Float2ReferenceRBTreeMap<V> |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Float2ReferenceSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Float2ReferenceSortedMaps.EmptySortedMap<V> |
An immutable class representing an empty type-specific sorted map.
|
| Float2ReferenceSortedMaps.Singleton<V> |
An immutable class representing a type-specific singleton sorted map.
|
| Float2ReferenceSortedMaps.SynchronizedSortedMap<V> |
A synchronized wrapper class for sorted maps.
|
| Float2ReferenceSortedMaps.UnmodifiableSortedMap<V> |
An unmodifiable wrapper class for sorted maps.
|
| 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.
|
| Float2ShortFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| 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.
|
| Float2ShortMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| 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.
|
| Float2ShortSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Float2ShortSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Float2ShortSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Float2ShortSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Float2ShortSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| FloatArrayFIFOQueue |
A type-specific array-based FIFO queue, supporting also deque operations.
|
| FloatArrayIndirectPriorityQueue |
A type-specific array-based semi-indirect priority queue.
|
| FloatArrayList |
A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing.
|
| FloatArrayPriorityQueue |
A type-specific array-based priority queue.
|
| FloatArrays |
A class providing static methods and objects that do useful things with type-specific arrays.
|
| FloatArrays.ForkJoinQuickSort | |
| FloatArrays.ForkJoinQuickSort2 | |
| FloatArrays.ForkJoinQuickSortComp | |
| FloatArrays.ForkJoinQuickSortIndirect | |
| FloatArrays.Segment | |
| FloatArraySet |
A simple, brute-force implementation of a set based on a backing array.
|
| FloatAVLTreeSet |
A type-specific AVL tree set with a fast, small-footprint implementation.
|
| FloatBigArrayBigList |
A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing.
|
| FloatBigArrays |
A class providing static methods and objects that do useful things with big arrays.
|
| FloatBigListIterators |
A class providing static methods and objects that do useful things with type-specific iterators.
|
| FloatBigListIterators.BigListIteratorListIterator |
A class exposing a list iterator as a big-list iterator..
|
| FloatBigListIterators.EmptyBigListIterator |
A class returning no elements and a type-specific big list iterator interface.
|
| FloatBigListIterators.UnmodifiableBigListIterator |
An unmodifiable wrapper class for big list iterators.
|
| FloatBigLists |
A class providing static methods and objects that do useful things with type-specific big lists.
|
| FloatBigLists.EmptyBigList |
An immutable class representing an empty type-specific big list.
|
| FloatBigLists.ListBigList |
A class exposing a list as a big list.
|
| FloatBigLists.Singleton |
An immutable class representing a type-specific singleton big list.
|
| FloatBigLists.SynchronizedBigList |
A synchronized wrapper class for big lists.
|
| FloatBigLists.UnmodifiableBigList |
An unmodifiable wrapper class for big lists.
|
| FloatCollections |
A class providing static methods and objects that do useful things with type-specific collections.
|
| FloatCollections.EmptyCollection |
An immutable class representing an empty type-specific collection.
|
| FloatCollections.IterableCollection |
A collection wrapper class for iterables.
|
| FloatCollections.SynchronizedCollection |
A synchronized wrapper class for collections.
|
| FloatCollections.UnmodifiableCollection |
An unmodifiable wrapper class for collections.
|
| FloatComparators |
A class providing static methods and objects that do useful things with comparators.
|
| FloatComparators.NaturalImplicitComparator |
A type-specific comparator mimicking the natural order.
|
| FloatComparators.OppositeComparator | |
| FloatComparators.OppositeImplicitComparator |
A type-specific comparator mimicking the opposite of the natural order.
|
| FloatHeapIndirectPriorityQueue |
A type-specific heap-based indirect priority queue.
|
| FloatHeapPriorityQueue |
A type-specific heap-based priority queue.
|
| FloatHeaps |
A class providing static methods and objects that do useful things with heaps.
|
| FloatHeapSemiIndirectPriorityQueue |
A type-specific heap-based semi-indirect priority queue.
|
| FloatIndirectHeaps |
A class providing static methods and objects that do useful things with indirect heaps.
|
| FloatIterators |
A class providing static methods and objects that do useful things with type-specific iterators.
|
| FloatIterators.ByteIteratorWrapper |
A wrapper promoting the results of a ByteIterator.
|
| FloatIterators.EmptyIterator |
A class returning no elements and a type-specific iterator interface.
|
| FloatIterators.ShortIteratorWrapper |
A wrapper promoting the results of a ShortIterator.
|
| FloatIterators.UnmodifiableBidirectionalIterator |
An unmodifiable wrapper class for bidirectional iterators.
|
| FloatIterators.UnmodifiableIterator |
An unmodifiable wrapper class for iterators.
|
| FloatIterators.UnmodifiableListIterator |
An unmodifiable wrapper class for list iterators.
|
| 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.
|
| FloatLists |
A class providing static methods and objects that do useful things with type-specific lists.
|
| FloatLists.EmptyList |
An immutable class representing an empty type-specific list.
|
| FloatLists.Singleton |
An immutable class representing a type-specific singleton list.
|
| FloatLists.SynchronizedList |
A synchronized wrapper class for lists.
|
| FloatLists.SynchronizedRandomAccessList |
A synchronized wrapper class for random-access lists.
|
| FloatLists.UnmodifiableList |
An unmodifiable wrapper class for lists.
|
| FloatLists.UnmodifiableRandomAccessList |
An unmodifiable wrapper class for random-access 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.
|
| FloatPriorityQueues |
A class providing static methods and objects that do useful things with type-specific priority queues.
|
| FloatPriorityQueues.SynchronizedPriorityQueue |
A synchronized wrapper class for priority queues.
|
| FloatRBTreeSet |
A type-specific red-black tree set with a fast, small-footprint implementation.
|
| FloatSemiIndirectHeaps |
A class providing static methods and objects that do useful things with semi-indirect heaps.
|
| FloatSets |
A class providing static methods and objects that do useful things with type-specific sets.
|
| 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.
|
| FloatSortedSets |
A class providing static methods and objects that do useful things with type-specific sorted sets.
|
| FloatSortedSets.EmptySet |
An immutable class representing the empty sorted set and implementing a type-specific set interface.
|
| FloatSortedSets.Singleton |
A class representing a singleton sorted set.
|
| FloatSortedSets.SynchronizedSortedSet |
A synchronized wrapper class for sorted sets.
|
| FloatSortedSets.UnmodifiableSortedSet |
An unmodifiable wrapper class for sorted sets.
|
Provides type-specific classes for float elements or keys.
Copyright © 2019. All rights reserved.


Bug 1507189 R[Core:Layout]Replace nsIPresShell::ScrollDirection with an enumset over layers::ScrollDirection
Bug 1669007 R[Core:Layout]Intermittent layout/generic/test/test_scroll_position_restore.html | undefined assertion name - got 54560, expected 348260
Bug 1672786 R[Core:Layout: Form Controls]Delimiters inside <input type=date> should not be selectable (or the whole text should be selectable)
Bug 1641287 R[Firefox:Address Bar]Malicious website can hijack Google search initiated from search bar
Bug 727668 R[Firefox:New Tab Page]Show bookmarks from the bookmarks toolbar in the new tab page
###########
Changes to 5 bugs - 5 fixed.
1 bugs are not included due to being restricted


Photographer: Hau Furkan
Likes: 3
Category: Beauty/Fashion
Description: Some description here...
Price: $2
Thanks for the feedback!


Badge Color
Unfortuantely, the browser predetermines thefont size of the badge. Setting the badge text color is available in Firefox 63 and above.
Automatically set Badge Color
When checked, the text color is either white or black based on the highest constrast with the badge color. When unchecked, a manual color may be selected.
Badge Text Color (if not automatic)
This option is ignored/disabled unless "Automatically set Badge Color" is unchecked.
Icon Color & Style
Tab Counter Default
Tab Counter Gray 90 (Firefox Photon Design System Light Background Icon Color)
Tab Counter Gray 10 (Firefox Photon Design System Dark Background Icon Color)
Tab Counter Black
Tab Counter White
Clear SVG for Firefox (shows badge only)
Clear 1px PNG for Opera (shows badge only)
Counter
Number of Tabs in Current Window
Total Number of Tabs of All Windows
Both Number of Tabs in Current Window/Total Number of Tabs of All Windows
Total Number of Windows
None (disables the counter and hover text; click the icon to see the count)
A maximum of four characters can be displayed on the badge; this is a browser limitation.


- set background image on report page
- set background color on report page
- use property "Fill Capacity"
- set gradient colors and direction of the gradient for "Rectangle Shape"
- use data streams in simple way if you have lots of them
- use property "Available On Every Page"
- see report preview, how it will look like once when it is generated


These datasets and functions accompany Wolfe and Schneider (2017) - Intuitive Introductory Statistics (ISBN: 978-3-319-56070-0) <http://www.springer.com/us/book/9783319560700>. They are used in the examples throughout the text and in the end-of-chapter exercises. The datasets are meant to cover a broad range of topics in order to appeal to the diverse set of interests and backgrounds typically present in an introductory Statistics class.
| Version: | 1.0 |
| Depends: | R (≥ 2.10) |
| Imports: | asbio, BSDA, Hmisc, NSM3, Rfit |
| Published: | 2017-10-06 |
| Author: | Grant Schneider |
| Maintainer: | Grant Schneider <gschneidz at gmail.com> |
| License: | GPL-2 |
| NeedsCompilation: | no |
| CRAN checks: | IIS results |
| Reference manual: | IIS.pdf |
| Package source: | IIS_1.0.tar.gz |
| Windows binaries: | r-devel: IIS_1.0.zip, r-release: IIS_1.0.zip, r-oldrel: IIS_1.0.zip |
| OS X binaries: | r-release: IIS_1.0.tgz, r-oldrel: IIS_1.0.tgz |
Please use the canonical form https://CRAN.R-project.org/package=IIS to link to this page.


Our Work
Centre Francophone de Toronto Volunteer Campaign
Laidlaw Foundation Annual Report
UNITY Festival 2015 Campaign
CoPower
CAA Learning Tools & Resources
Smart Serve Subway Public Awareness Campaign