| Opcode | Instruction | 64-Bit Mode | Compat/Leg Mode | Description |
|---|---|---|---|---|
| D9 F1 | FYL2X | Valid | Valid | Replace ST(1) with (ST(1) ∗ log2ST(0)) and pop the register stack. |
Computes (ST(1) ∗ log2 (ST(0))), stores the result in resister ST(1), and pops the FPU register stack. The source operand in ST(0) must be a non-zero positive number.
The following table shows the results obtained when taking the log of various classes of numbers, assuming that neither overflow nor underflow occurs.
| ST(0) | |||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| − ∞ | − F | ±0 | +0<+F<+1 | + 1 | + F > + 1 | + ∞ | NaN | ||||||||||||
| − ∞ | * | * | + ∞ | + ∞ | * | − ∞ | − ∞ | NaN | |||||||||||
| ST(1) | − F | * | * | ** | + F | − 0 | − F | − ∞ | NaN | ||||||||||
| − 0 | * | * | * | + 0 | − 0 | − 0 | * | NaN | |||||||||||
| + 0 | * | * | * | − 0 | + 0 | + 0 | * | NaN | |||||||||||
| + F | * | * | ** | − F | + 0 | + F | + ∞ | NaN | |||||||||||
| + ∞ | * | * | − ∞ | − ∞ | * | + ∞ | + ∞ | NaN | |||||||||||
| NaN | NaN | NaN | NaN | NaN | NaN | NaN | NaN | NaN |
NOTES:
F Means finite floating-point value.
*
Indicates floating-point invalid-operation (#IA) exception.
** Indicates floating-point zero-divide (#Z) exception.
If the divide-by-zero exception is masked and register ST(0) contains ±0, the instruction returns ∞ with a sign that is the opposite of the sign of the source operand in register ST(1).
The FYL2X instruction is designed with a built-in multiplication to optimize the calculation of logarithms with an arbitrary positive base (b):
logbx ← (log2b)–1 ∗ log2x
This instruction’s operation is the same in non-64-bit modes and 64-bit mode.
ST(1) ← ST(1) ∗ log2ST(0); PopRegisterStack;
| C1 |
Set to 0 if stack underflow occurred. Set if result was rounded up; cleared otherwise. |
| C0, C2, C3 | Undefined. |
| #IS | Stack underflow occurred. |
| #IA |
Either operand is an SNaN or unsupported format. Source operand in register ST(0) is a negative finite value (not -0). |
#Z
Source operand in register ST(0) is ±0.
#D
Source operand is a denormal value.
#U
Result is too small for destination format.
#O
Result is too large for destination format.
#P
Value cannot be represented exactly in destination format.
| #NM | CR0.EM[bit 2] or CR0.TS[bit 3] = 1. |
| #MF | If there is a pending x87 FPU exception. |
| #UD | If the LOCK prefix is used. |
Same exceptions as in protected mode.
Same exceptions as in protected mode.
Same exceptions as in protected mode.
Same exceptions as in protected mode.


hiiiiiii
hii Our extensive learning guides provide a deep dive into various types of software development. Improve your WordPress knowledge, learn Ruby or PHP, get started with Swift and iOS, and much more. Each learning guide will help you master a topic from start to finish. Begin one of our learning guides today and see where it takes you!


Enum VertexBuffer.Type
- java.lang.Object
-
- java.lang.Enum<VertexBuffer.Type>
-
- com.jme.scene.VertexBuffer.Type
-
- All Implemented Interfaces:
java.io.Serializable
,java.lang.Comparable<VertexBuffer.Type>
- Enclosing class:
- VertexBuffer
public static enum VertexBuffer.Type extends java.lang.Enum<VertexBuffer.Type>
Type of buffer. Specifies the actual attribute it defines.
-
-
Enum Constant Summary
Enum Constants Enum Constant Description BindPoseNormal
Initial vertex normals, used with animation.BindPosePosition
Initial vertex position, used with animation.BindPoseTangent
Initial vertex tangents, used with animation.Binormal
Binormal vector, normalized (3 floats, optional)BoneIndex
Bone indices, used with animation (4 ubytes).BoneWeight
Bone weights, used with animation (4 floats).Color
Color and Alpha (4 floats)HWBoneIndex
Bone indices, used with animation (4 ubytes).HWBoneWeight
Bone weights, used with animation (4 floats).Index
Specifies the index buffer, must contain integer data (ubyte, ushort, or uint).InstanceData
Information about this instance.InterleavedData
Specifies the source data for various vertex buffers when interleaving is used.MorphTarget0
Morph animations targets.MorphTarget1
MorphTarget10
MorphTarget11
MorphTarget12
MorphTarget13
MorphTarget2
MorphTarget3
MorphTarget4
MorphTarget5
MorphTarget6
MorphTarget7
MorphTarget8
MorphTarget9
Normal
Normal vector, normalized (3 floats).Position
Position of the vertex (3 floats)Reserved0
Deprecated.Size
The size of the point when using point buffers (float).Tangent
Tangent vector, normalized (4 floats) (x,y,z,w).TexCoord
Texture coordinate (2 float)TexCoord2
Texture coordinate #2TexCoord3
Texture coordinate #3TexCoord4
Texture coordinate #4TexCoord5
Texture coordinate #5TexCoord6
Texture coordinate #6TexCoord7
Texture coordinate #7TexCoord8
Texture coordinate #8
-
Method Summary
All Methods Static Methods Concrete Methods Modifier and Type Method Description static VertexBuffer.Type
valueOf(java.lang.String name)
Returns the enum constant of this type with the specified name.static VertexBuffer.Type[]
values()
Returns an array containing the constants of this enum type, in the order they are declared.
-
-
-
Enum Constant Detail
-
Position
public static final VertexBuffer.Type Position
Position of the vertex (3 floats)
-
Size
public static final VertexBuffer.Type Size
The size of the point when using point buffers (float).
-
Normal
public static final VertexBuffer.Type Normal
Normal vector, normalized (3 floats).
-
TexCoord
public static final VertexBuffer.Type TexCoord
Texture coordinate (2 float)
-
Color
public static final VertexBuffer.Type Color
Color and Alpha (4 floats)
-
Tangent
public static final VertexBuffer.Type Tangent
Tangent vector, normalized (4 floats) (x,y,z,w). The w component is called the binormal parity, is not normalized, and is either 1f or -1f. It's used to compute the direction on the binormal vector on the GPU at render time.
-
Binormal
public static final VertexBuffer.Type Binormal
Binormal vector, normalized (3 floats, optional)
-
InterleavedData
public static final VertexBuffer.Type InterleavedData
Specifies the source data for various vertex buffers when interleaving is used. By default the format is byte.
-
Reserved0
@Deprecated public static final VertexBuffer.Type Reserved0
Deprecated.Do not use.
-
Index
public static final VertexBuffer.Type Index
Specifies the index buffer, must contain integer data (ubyte, ushort, or uint).
-
BindPosePosition
public static final VertexBuffer.Type BindPosePosition
Initial vertex position, used with animation. Should have the same format and size asPosition
. If used with software skinning, the usage should beVertexBuffer.Usage.CpuOnly
, and the buffer should be allocated on the heap.
-
BindPoseNormal
public static final VertexBuffer.Type BindPoseNormal
Initial vertex normals, used with animation. Should have the same format and size asNormal
. If used with software skinning, the usage should beVertexBuffer.Usage.CpuOnly
, and the buffer should be allocated on the heap.
-
BoneWeight
public static final VertexBuffer.Type BoneWeight
Bone weights, used with animation (4 floats). Only used for software skinning, the usage should beVertexBuffer.Usage.CpuOnly
, and the buffer should be allocated on the heap.
-
BoneIndex
public static final VertexBuffer.Type BoneIndex
Bone indices, used with animation (4 ubytes). Only used for software skinning, the usage should beVertexBuffer.Usage.CpuOnly
, and the buffer should be allocated on the heap as a ubytes buffer.
-
TexCoord2
public static final VertexBuffer.Type TexCoord2
Texture coordinate #2
-
TexCoord3
public static final VertexBuffer.Type TexCoord3
Texture coordinate #3
-
TexCoord4
public static final VertexBuffer.Type TexCoord4
Texture coordinate #4
-
TexCoord5
public static final VertexBuffer.Type TexCoord5
Texture coordinate #5
-
TexCoord6
public static final VertexBuffer.Type TexCoord6
Texture coordinate #6
-
TexCoord7
public static final VertexBuffer.Type TexCoord7
Texture coordinate #7
-
TexCoord8
public static final VertexBuffer.Type TexCoord8
Texture coordinate #8
-
BindPoseTangent
public static final VertexBuffer.Type BindPoseTangent
Initial vertex tangents, used with animation. Should have the same format and size asTangent
. If used with software skinning, the usage should beVertexBuffer.Usage.CpuOnly
, and the buffer should be allocated on the heap.
-
HWBoneWeight
public static final VertexBuffer.Type HWBoneWeight
Bone weights, used with animation (4 floats). for Hardware Skinning only
-
HWBoneIndex
public static final VertexBuffer.Type HWBoneIndex
Bone indices, used with animation (4 ubytes). for Hardware Skinning only either an int or float buffer due to shader attribute types restrictions.
-
InstanceData
public static final VertexBuffer.Type InstanceData
Information about this instance. Format should beVertexBuffer.Format.Float
and number of components should be 16.
-
MorphTarget0
public static final VertexBuffer.Type MorphTarget0
Morph animations targets. Supports up tp 14 morph target buffers at the same time Limited due to the limited number of attributes you can bind to a vertex shader usually 16MorphTarget buffers are either POSITION, NORMAL or TANGENT buffers. So we can support up to 14 simultaneous POSITION targets 7 simultaneous POSITION and NORMAL targets 4 simultaneous POSTION, NORMAL and TANGENT targets.
Note that the MorphControl will find how many buffers can be supported for each mesh/material combination. Note that all buffers have 3 components (Vector3f) even the Tangent buffer that does not contain the w (handedness) component that will not be interpolated for morph animation.
Note that those buffers contain the difference between the base buffer (POSITION, NORMAL or TANGENT) and the target value So that you can interpolate with a MADD operation in the vertex shader position = weight * diffPosition + basePosition;
-
MorphTarget1
public static final VertexBuffer.Type MorphTarget1
-
MorphTarget2
public static final VertexBuffer.Type MorphTarget2
-
MorphTarget3
public static final VertexBuffer.Type MorphTarget3
-
MorphTarget4
public static final VertexBuffer.Type MorphTarget4
-
MorphTarget5
public static final VertexBuffer.Type MorphTarget5
-
MorphTarget6
public static final VertexBuffer.Type MorphTarget6
-
MorphTarget7
public static final VertexBuffer.Type MorphTarget7
-
MorphTarget8
public static final VertexBuffer.Type MorphTarget8
-
MorphTarget9
public static final VertexBuffer.Type MorphTarget9
-
MorphTarget10
public static final VertexBuffer.Type MorphTarget10
-
MorphTarget11
public static final VertexBuffer.Type MorphTarget11
-
MorphTarget12
public static final VertexBuffer.Type MorphTarget12
-
MorphTarget13
public static final VertexBuffer.Type MorphTarget13
-
-
Method Detail
-
values
public static VertexBuffer.Type[] values()
Returns an array containing the constants of this enum type, in the order they are declared. This method may be used to iterate over the constants as follows:for (VertexBuffer.Type c : VertexBuffer.Type.values()) System.out.println(c);
- Returns:
- an array containing the constants of this enum type, in the order they are declared
-
valueOf
public static VertexBuffer.Type valueOf(java.lang.String name)
Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)- Parameters:
name
- the name of the enum constant to be returned.- Returns:
- the enum constant with the specified name
- Throws:
java.lang.IllegalArgumentException
- if this enum type has no constant with the specified namejava.lang.NullPointerException
- if the argument is null
-
-


For the 2nd year group project in our university we needed to solve a problem that most of the people are facing in the society. So we found that there are no efficeint way to communicate between workers and their customers. So we needed to build the bridge between them
After gathering all the requirements all four members started to Implementations.
According to our plan we successfully developed our system (according to the time line). Final testing stages did on january
Developer
Developer
Developer
Developer
You can register as a worker and you can manage your profile with our web-site. And also you can gather more customers
You can find the most suitable woker for you according to your desires. And also you can book them and rate them.
You can promote your company/shop using our site for affortable cost


The Prestige tab is unlocked by completely defeating the first enemy (clearing
all 100 cells). Prestige will reset your Miners but give you additional skill
points to spend in the Prestige Skill Tree. The number of points you gain is
equal to the highest level enemy defeated plus ascension_level, subtracting
your current prestige level. To get more points, defeat higher level enemies.
By defeating enemies of level >=2 you will gain Inactive dark matter. When you
prestige this dark matter will become activated, and you can use this Dark
Matter to time warp. 60 units of Dark Matter equals one minute of time
skipped. Automators and Battle will not occur in the skipped time.
Prestige will also unlock Automators.


Recursion level:
0
Transition duration:
X-Size:
Save proportions:
Y-Size:
X-Mirror:
Y-Mirror:
Dragon curve on Wikipedia


Home
What is LinkedIn?
Join Today
Sign in
Email:
Password:
Over 175 million professionals use LinkedIn to exchange information, ideas and opportunities
Stay informed about your contacts and industry
Find the people & knowledge you need to achieve your goals
Control your professional identity online
Join LinkedIn Today
Sign Up
First Name:
Last Name:
E-mail:
Password:
6 or more characters
*
Already on LinkedIn?
Sign in
.
Search for someone by name:
First Name:
Last Name:


Chryz-Hub
The World of Open Source, Where Your Ideas and Contributions Count and are Highly Appreciated
The World of Open Source, Where Your Ideas and Contributions Count and are Highly Appreciated
Our vision is to add value, solve problems, render help and support to developers, open source contributors and everyone at large and also raise and build Open Source Giants.
Read more


|
MRSL Motion Primitive Library
0.4
A motion primitive library for generating trajectory for mobile robots
|
yamp map reader More...
#include <map_reader.hpp>
Public Member Functions | |
| MapReader (const std::string &file, bool verbose=false) | |
| Simple constructor. More... | |
| bool | exist () |
| Check if a map is loaded successfully. | |
| Tf | origin () |
| Get the map origin. | |
| Ti | dim () |
| Get the map dimension. | |
| double | resolution () |
| Get the map resolution. | |
| std::vector< signed char > | data () |
| Get the map entity. | |
Private Attributes | |
| Tf | origin_ |
| Map origin, float type. | |
| Ti | dim_ |
| Map dimension, int type. | |
| double | resolution_ |
| Map resolution, float type. | |
| std::vector< signed char > | data_ |
Map entity, vector of signed char | |
| bool | exist_ = false |
| Flag of the map exsistence. | |
yamp map reader
|
inline |
Simple constructor.
| file | the yaml file name (with path) |
| verbose | enable printing if true, default as false |


|
Copley Motion Library
|
The EtherCAT class is the top level interface into the EtherCAT network. More...
Public Member Functions | |
| NetworkType | GetNetworkType (void) |
| Return the network type. More... | |
| const Error * | GetIdFromEEPROM (Node *n, struct NodeIdentity &id) |
| Read the node ID info that was pullsed from EEPROM on startup. More... | |
| const Error * | SetNodeGuard (Node *n, GuardProtocol type, Timeout timeout=200, uint8 life=0) |
| Configure the heartbeat protocol for an EtherCAT node. More... | |
| const Error * | SetSync0Period (Node *n, uint32 ns) |
| Set the period of the SYNC0 signal used on nodes with a distributed clock. More... | |
| uint16 | getNodeCount (void) |
| Return the number of nodes discovered on the network. More... | |
| const Error * | GetNodeAddress (Node *n, uint16 &addr) |
| Return the EtherCAT address assigned to this node. More... | |
| const Error * | FoE_DnldStart (Node *n, const char *filename, uint32 password, Timeout to=2000) |
| Initiate a new file download using the File over EtherCAT (FoE) protocol. More... | |
| const Error * | FoE_DnldData (Node *n, int32 len, uint8 *buff, Timeout to=2000, bool end=true) |
| Download a block of file data to a node using the File over EtherCAT (FoE) protocol. More... | |
| const Error * | FoE_UpldStart (Node *n, const char *filename, uint32 password, Timeout to=2000) |
| Initiate a new file upload using the File over EtherCAT (FoE) protocol. More... | |
| const Error * | FoE_UpldData (Node *n, int32 max, int32 *len, uint8 *data, Timeout to=2000) |
| Upload a block of file data from a node using the File over EtherCAT (FoE) protocol. More... | |
| int32 | FoE_LastErrInfo (Node *n, char *msg, int maxMsg) |
| Return the detailed error code and message for the most recent FoE error response on this node. More... | |
| int32 | maxSdoToNode (Node *n) |
| Return the maximum number of bytes that can be sent in an SDO message. More... | |
| int32 | maxSdoFromNode (Node *n) |
| Return the maximum number of bytes that can be received in an SDO message. More... | |
| const Error * | WaitCycleUpdate (Timeout to) |
| Wait for the cyclic thread to update. More... | |
| Public Member Functions inherited from RefObj | |
| RefObj (const char *name=0) | |
| Default constructor for a reference object. More... | |
| virtual | ~RefObj () |
| Reference object destructor. More... | |
| void | SetRefName (const char *name) |
| Assign a name to this reference. More... | |
| uint32 | GrabRef (void) |
| Grab a reference to this object. More... | |
| void | setAutoDelete (bool autoDeleteEna) |
| This function is used to enable or disable the autodelete function for a reference object. More... | |
| void | UnlockRef (void) |
| Unlock an object that was previously locked using RefObj::Lock. | |
Protected Member Functions | |
| const Error * | InitDistClk (void) |
| Initialize the distributed clock system on this network. More... | |
| const Error * | MailboxTransfer (Node *n, uint16 len, uint16 *ret, Timeout timeout=2000) |
| Write a block of data to the mailbox of an EtherCAT node and wait for a response. More... | |
| const Error * | AddToFrame (class EcatFrame *frame, class EcatDgram *dg) |
| Add a datagram to the frame. More... | |
| Protected Member Functions inherited from RefObj | |
| void | KillRef (void) |
| Destroy this reference. More... | |
Friends | |
| class | Linkage |
| class | Node |
Additional Inherited Members | |
| Static Public Member Functions inherited from RefObj | |
| static void | ReleaseRef (uint32 id) |
| Release the local reference to this object. More... | |
| static RefObj * | LockRef (uint32 id) |
| Find the object associated with the passed reference number and lock it to prevent the object from being destroyed while I'm accessing it. More... | |
| static void | LogRefs (void) |
| This function is provided for debugging. More... | |
| Static Protected Member Functions inherited from Network | |
| static NetworkNodeInfo * | GetNodeInfo (Node *n) |
| Return a pointer to the network information union embedded in this node. More... | |
| static void | SetNodeInfo (Node *n, NetworkNodeInfo *ni) |
| Set the network's node information for this node. More... | |
The EtherCAT class is the top level interface into the EtherCAT network.
There should be at least one object of this class in every EtherCAT based application.
Add a datagram to the frame.
If the frame is too large to add the datagram, then first send the frame, reset it and add the datagram.
| frame | The frame |
| dg | The datagram |
| const Error * FoE_DnldData | ( | Node * | n, |
| int32 | len, | ||
| uint8 * | data, | ||
| Timeout | to = 2000 , |
||
| bool | end = true |
||
| ) |
Download a block of file data to a node using the File over EtherCAT (FoE) protocol.
The transfer should have been previously initialized by calling the EtherCAT::FoE_DnldStart function.
| n | Pointer to the node to download to |
| len | Length of data to download in bytes |
| data | Buffer holding the data to download |
| to | A timeout value. |
| end | True if this is the last block of data to be sent |
Initiate a new file download using the File over EtherCAT (FoE) protocol.
This function should be used to start a new file download. On success, the EtherCAT::FoE_DnldData function can be used to pass the file data.
| n | Points to the node who will receive this download |
| filename | Name of the file to be sent. May be null if no file name is to be passed. |
| password | Optional password value to be sent to the slave device (0 if not used) |
| to | Timeout to wait for response. |
Return the detailed error code and message for the most recent FoE error response on this node.
| n | Points to the node in question |
| msg | Buffer where error message should be stored (can be null) |
| maxMsg | Size of the message buffer |
Upload a block of file data from a node using the File over EtherCAT (FoE) protocol.
The transfer should have been previously initialized by calling the EtherCAT::FoE_UpldStart function.
| n | Pointer to the node to upload from |
| max | Maximum length of data to upload in bytes |
| len | On return, holds the actual number of bytes uploaded. |
| data | Buffer where data will be written |
| to | A timeout value. |
Initiate a new file upload using the File over EtherCAT (FoE) protocol.
This function should be used to start a new file upload. On success, the EtherCAT::FoE_UpldData function can be used to read the file data.
| n | Points to the node from which the data will be uploaded. |
| filename | Name of the file to be read. May be null if no file name is to be passed. |
| password | Optional password value to be sent to the slave device (0 if not used) |
| to | Timeout to wait for response. |
| const Error * GetIdFromEEPROM | ( | Node * | n, |
| struct NodeIdentity & | id | ||
| ) |
Read the node ID info that was pullsed from EEPROM on startup.
This can be useful on nodes that don't support the CoE protocol and therefor can't use the more standard Node::GetIdentity method.
| n | Points to the node to access |
| id | Structure where identiy info will be returned |
|
inlinevirtual |
Return the EtherCAT address assigned to this node.
When each node is added to an EtherCAT network, the network object assigns it a unique address. This address is then used by the master to communicate with the node over the network.
| n | Pointer to the node object |
| addr | The assigned address will be returned here |
|
inline |
Return the number of nodes discovered on the network.
|
protected |
Initialize the distributed clock system on this network.
This is called at startup by EtherCAT::Open();
|
protected |
Write a block of data to the mailbox of an EtherCAT node and wait for a response.
Note that the mailbox mutex should be held when this is called.
| n | The node to access. |
| len | The number of bytes of data to send |
| ret | returns the actual number of bytes returned. |
| timeout | The maximum time to wait for a response. |
Return the maximum number of bytes that can be received in an SDO message.
For CANopen this is always 8 (the max size of a CAN frame). For EtherCAT it's the size of the mailbox buffer, and is node specific
| n | The node to query |
Reimplemented from Network.
Return the maximum number of bytes that can be sent in an SDO message.
For CANopen this is always 8 (the max size of a CAN frame). For EtherCAT it's the size of the mailbox buffer, and is node specific
| n | The node to query |
Reimplemented from Network.
|
virtual |
Configure the heartbeat protocol for an EtherCAT node.
This sets the heartbeat timeout used for process data on the EtherCAT node.
| n | The node to configure heartbeat on |
| type | The type of node guarding to configure. |
| timeout | A timeout (milliseconds) to use for this node guarding protocol. If not specified, this parameter defaults to 200 milliseconds. |
| life | This parameter is not used under EtherCAT. |
Implements Network.
Set the period of the SYNC0 signal used on nodes with a distributed clock.
This also starts generation of the SYNC0 signal.
| n | The node to modify |
| ns | The period in nanoseconds. |
| const Error * WaitCycleUpdate | ( | Timeout | to | ) |
Wait for the cyclic thread to update.
| to | Max time to wait before returning an error |


Zappem can handle exceptions from all your different projects, and the exceptions will be grouped together nicely.
You can invite others users to specific projects and then assign exceptions to them.


Sacramento Hospitality Group was founded in 2019 in Sacramento, California with the intention to help out
those in need in our community. Today, we create original nonprofit events that help fundraise for
homelessness, COVID-19 relief and civil rights organizations. We have worked with Loaves and Fishes, Direct
Relief Fund, The World Health Organization, United Way, NAACP and more.
We aim to work with even more contributors and local non-profits in 2021 and beyond. We're always welcoming
friendly and community-conscious members, so stay tuned and join us for our upcoming events!
© Copyright.


-
Premier Wellness Care in B/CS
At Vitality Family Chiropractic, we are committed to keeping you and your family healthy for the rest of your life.
-
Monthly Workshops
Visit our events page to learn about our monthly events to help you achieve your health goals.
-
Pediatric Chiropractic
Learn more about how chiropractic can benefit our favorite patients – your children.
-
Get Started Today
Request an appointment today to take the first step towards your new healthy lifestyle.


| id | ref | Period | Landscape | Source | Details |
|---|---|---|---|---|---|
| 2 | о. Бельковский - встречи | Summer | Just islands | Local knowledge Direct observations |
Polar bears are rare. Information is provided by hunters (Kitschinsky, 1969). Aerial survey in October 2010. |
| 3 | Сев. о. Котельный – встречи | Summer | Coastline only | Direct observations | Polar bears are rare. Aerial survey in October 2010. A spot is referred to walrus rookery. |
| 5 | Северо-Восток Таймыра – встречи | Summer | Coastline only | Direct observations | Polar bears are rare. Occasional registrations during aerial survey in September 2010 along shore. |
| 6 | о. Новая Сибирь – встречи | Summer | Coastline only | Direct observations | Polar bears are rare. Data are retrieved from landing in August 2012. |
| 7 | о-ва Де-Лонга – встречи | Summer | Just islands | Direct observations | Polar bears are rare. Data are retrieved from landing in August 2012. |
| 8 | Восток Таймыра – встречи | Summer | Coastline only | Direct observations | Polar bears are rare. Their spots are referred to walrus rookeries. |
| 9 | Медвежьи о-ва – берлоги | Denning | Just islands | Direct observations | The most well-known regional denning area. Single dens are reported by Uspensky (1989). Confirmed by “Umka Patrol” in 2021. |
| 10 | Побережье Колымы | Denning | Land Areas | Direct observations | Polar bears are rare. Non-recent occasional observations. |
| 11 | Айон – берлоги | Denning | Land Areas | Direct observations Expert opinion |
Polar bears are rare. Non-recent occasional observations (Uspensky 1989). Occurrence of COYs in spring period. |
| 12 | о. Бельсковский - берлоги | Denning | Land Areas | Local knowledge | Polar bears are rare. Not-recent information is provided by hunters (Kitschinsky, 1969) |
| 13 | Сев. о. Котельный - берлоги | Denning | Land Areas | Local knowledge | Polar bears are rare. Not-recent information is provided by hunters (Kitschinsky, 1969) |
| 14 | сев. З. Бунге – берлоги | Denning | Land Areas | Local knowledge | Polar bears are rare. Not-recent information is provided by hunters (Kitschinsky, 1969) |
| 15 | о. Нов. Сибирь – берлоги | Denning | Land Areas | Local knowledge | Polar bears are rare. Not-recent information is provided by hunters (Kitschinsky, 1969) |
| 16 | Сев. Земля – берлоги | Denning | Land Areas | Direct observations | Polar bears are rare. Non-recent in 1990s. |
| 17 | Восточный Таймыр – берлоги | Denning | Land Areas | Direct observations Expert opinion |
Polar bears are rare. Not-recent information is provided by experts (Karpovitch, 1969) |
| 18 | Зимнее распределение — акватория | Winter | Ocean areas | Location data Habitat use characteristics Expert opinion |
Based on location data (without 09690) in 1990s during August-October with applied species distribution modeling (maxent), distribution of Great Siberian Polynya during 2009-2018 in March-May, and supplemental aerial survey during winter maximum in 1958-1995 (Belikov, 2011, Figure 4) |
| 19 | Летнее распределение — акватория | Summer | Ocean areas | Location data Habitat use characteristics Expert opinion |
Based on location data (without 09690) in 1990s during August-October with applied species distribution modeling (maxent), median 2001-2020 sea ice edge (15% sea ice concentration) position during August-October, and supplemental aerial survey during August-September in 1958-1995 (Belikov, 2011, Figure 6) |
| id | ref | Period | Landscape | Source | Details |
|---|---|---|---|---|---|
| 4 | Восток моря Лаптевых – встречи | Summer | Ocean areas | Direct observations Location data Habitat use characteristics |
Polar bears are rare. They were sighted during Kara-Winter-2014 (Petrov et al., 2018) and “Master of the Arctic – 2021” expeditions. There are biotelemetry data during period April 1994 – August 2016 (Mauritzen et al., 2002). Northern boundary is limited by distribution of Great Siberian Polynya during 2009-2018 in March-May. |
Rererences: Kitschinsky (1969); Karpovitch (1969); Беликов (2011); Успенский (1989); Petrov et al. (2018); Mauritzen et al. (2002).
Spelling: Успенский = Uspensky, Беликов = Belikov.
| id | ref | Period | Landscape | Source | Details |
|---|---|---|---|---|---|
| 2 | о. Бельковский - встречи | Summer | Just islands | Local knowledge Direct observations |
Polar bears are rare. Information is provided by hunters (Kitschinsky, 1969). Aerial survey in October 2010. |
| id | ref | Period | Landscape | Source | Details |
|---|---|---|---|---|---|
| 3 | Сев. о. Котельный – встречи | Summer | Coastline only | Direct observations | Polar bears are rare. Aerial survey in October 2010. A spot is referred to walrus rookery. |
| id | ref | Period | Landscape | Source | Details |
|---|---|---|---|---|---|
| 4 | Восток моря Лаптевых – встречи | Summer | Ocean areas | Direct observations Location data Habitat use characteristics |
Polar bears are rare. They were sighted during Kara-Winter-2014 (Petrov et al., 2018) and “Master of the Arctic – 2021” expeditions. There are biotelemetry data during period April 1994 – August 2016 (Mauritzen et al., 2002). Northern boundary is limited by distribution of Great Siberian Polynya during 2009-2018 in March-May. |
| id | ref | Period | Landscape | Source | Details |
|---|---|---|---|---|---|
| 5 | Северо-Восток Таймыра – встречи | Summer | Coastline only | Direct observations | Polar bears are rare. Occasional registrations during aerial survey in September 2010 along shore. |
| id | ref | Period | Landscape | Source | Details |
|---|---|---|---|---|---|
| 6 | о. Новая Сибирь – встречи | Summer | Coastline only | Direct observations | Polar bears are rare. Data are retrieved from landing in August 2012. |
| id | ref | Period | Landscape | Source | Details |
|---|---|---|---|---|---|
| 7 | о-ва Де-Лонга – встречи | Summer | Just islands | Direct observations | Polar bears are rare. Data are retrieved from landing in August 2012. |
| id | ref | Period | Landscape | Source | Details |
|---|---|---|---|---|---|
| 8 | Восток Таймыра – встречи | Summer | Coastline only | Direct observations | Polar bears are rare. Their spots are referred to walrus rookeries. |
| id | ref | Period | Landscape | Source | Details |
|---|---|---|---|---|---|
| 9 | Медвежьи о-ва – берлоги | Denning | Just islands | Direct observations | The most well-known regional denning area. Single dens are reported by Uspensky (1989). Confirmed by “Umka Patrol” in 2021. |
| id | ref | Period | Landscape | Source | Details |
|---|---|---|---|---|---|
| 10 | Побережье Колымы | Denning | Land Areas | Direct observations | Polar bears are rare. Non-recent occasional observations. |
| id | ref | Period | Landscape | Source | Details |
|---|---|---|---|---|---|
| 11 | Айон – берлоги | Denning | Land Areas | Direct observations Expert opinion |
Polar bears are rare. Non-recent occasional observations (Uspensky 1989). Occurrence of COYs in spring period. |
| id | ref | Period | Landscape | Source | Details |
|---|---|---|---|---|---|
| 12 | о. Бельсковский - берлоги | Denning | Land Areas | Local knowledge | Polar bears are rare. Not-recent information is provided by hunters (Kitschinsky, 1969) |
| id | ref | Period | Landscape | Source | Details |
|---|---|---|---|---|---|
| 13 | Сев. о. Котельный - берлоги | Denning | Land Areas | Local knowledge | Polar bears are rare. Not-recent information is provided by hunters (Kitschinsky, 1969) |
| id | ref | Period | Landscape | Source | Details |
|---|---|---|---|---|---|
| 14 | сев. З. Бунге – берлоги | Denning | Land Areas | Local knowledge | Polar bears are rare. Not-recent information is provided by hunters (Kitschinsky, 1969) |
| id | ref | Period | Landscape | Source | Details |
|---|---|---|---|---|---|
| 15 | о. Нов. Сибирь – берлоги | Denning | Land Areas | Local knowledge | Polar bears are rare. Not-recent information is provided by hunters (Kitschinsky, 1969) |
| id | ref | Period | Landscape | Source | Details |
|---|---|---|---|---|---|
| 16 | Сев. Земля – берлоги | Denning | Land Areas | Direct observations | Polar bears are rare. Non-recent in 1990s. |
| id | ref | Period | Landscape | Source | Details |
|---|---|---|---|---|---|
| 17 | Восточный Таймыр – берлоги | Denning | Land Areas | Direct observations Expert opinion |
Polar bears are rare. Not-recent information is provided by experts (Karpovitch, 1969) |
| id | ref | Period | Landscape | Source | Details |
|---|---|---|---|---|---|
| 18 | Зимнее распределение — акватория | Winter | Ocean areas | Location data Habitat use characteristics Expert opinion |
Based on location data (without 09690) in 1990s during August-October with applied species distribution modeling (maxent), distribution of Great Siberian Polynya during 2009-2018 in March-May, and supplemental aerial survey during winter maximum in 1958-1995 (Belikov, 2011, Figure 4) |
| id | ref | Period | Landscape | Source | Details |
|---|---|---|---|---|---|
| 19 | Летнее распределение — акватория | Summer | Ocean areas | Location data Habitat use characteristics Expert opinion |
Based on location data (without 09690) in 1990s during August-October with applied species distribution modeling (maxent), median 2001-2020 sea ice edge (15% sea ice concentration) position during August-October, and supplemental aerial survey during August-September in 1958-1995 (Belikov, 2011, Figure 6) |


FAQ
Do I need to have any prior experience with coding/programming to participate?
- Not really, however it's helpful to have the drive to learn stuff outside of the club meetings. We can help guide you.
What kind of hardware do I need?
- For yourself, pretty much anything you can run Google Docs on. The exception being chromebooks, you'll want to pull your hair out if you tried to code on one of those without experience or patience. If we work with more specialized hardware then it will be from the club's budget or donations.
What is a Hackathon?
- An event hosted by a tech company, school, or organization. Participants are given 24 hours to make some sort of project that is able to solve a problem of the judge's choosing. These judges will eventually look at what you made and award prizes based on merit. There will also be booths hosted by tech companies to teach their paid software development products, which usually takes care of funding for these events. The main utility that comes from participation is the fun factor, meeting new people and maybe the serotonin hit that comes from potentially earning a prize.
Who is this club for?
- Anyone who cares enough to participate and is willing to enjoy themselves working on software with other people


Claimant’s response |
|
In the County Court Business Centre |
|
Online Civil Money Claims |
|
Claim number: {{ claim.referenceNumber }} |
|
Issued on: {{ claim.issuedOn }} |
|
Claimant Response submitted on: {{ claimantSubmittedOn }} |
| Do you accept or reject the defendant’s admission? | {{ defendantAdmissionAccepted }} |
| Do you accept the defendant’s repayment plan? | {{ paymentPlanAccepted }} |
| How would you like the defendant to pay? | {{ paymentOption }} |
| Regular payments of: | {{ repaymentPlan.instalmentAmount }} |
| Frequency of payments: | {{ repaymentPlan.paymentSchedule }} |
| First payment by: | {{ repaymentPlan.firstPaymentDate }} |
| Last payment by: | {{ whenWillTheyFinishPaying }} |
| How the defendant will pay? | {{ courtPaymentIntentionpaymentOption }} |
| First payment by: | {{ courtPaymentIntentionrepaymentPlan.firstPaymentDate }} |
| Regular payments of: | {{ courtPaymentIntentionrepaymentPlan.instalmentAmount }} |
| Frequency of payments: | {{ courtPaymentIntentionrepaymentPlan.paymentSchedule }} |
| Last payment by: | {{ courtPaymentIntentionwhenWillTheyFinishPaying }} |
| How the defendant will pay? | {{ courtDecisionpaymentOption }} |
| First payment by: | {{ courtDecisionrepaymentPlan.firstPaymentDate }} |
| Regular payments of: | {{ courtDecisionrepaymentPlan.instalmentAmount }} |
| Frequency of payments: | {{ courtDecisionrepaymentPlan.paymentSchedule }} |
| Last payment by: | {{ courtDecisionwhenWillTheyFinishPaying }} |
| Rejection Reason | {{ rejectionReason }} |
| How do you want to formalise the repayment plan? | {{ formaliseOption }} |
| Has the defendant paid some of the amount owed? | {% if ccj.paidAmount is defined %} {{'Yes'}} {% else %} {{ 'No' }} {% endif %} |
| Total to be paid by defendant | {{ totalAmount }} |
| Why do you feel this plan is not affordable? | {{ reasonForReDeterminationdefendant }} |
| Why do you believe the defendant can repay you sooner? | {{ reasonForReDeterminationclaimant }} |


Write a short paragraph about yourself or some placeholder text.
A second short paragraph about yourself or some placeholder text.
| Books | Movies | Games |
|---|---|---|
| The Hobbit | Hot Fuzz | Dark Souls |
| The Name of the Wind | The Avengers | The Last of Us |
| The Girl With All the Gifts | The Matrix | Dragon Age: Origins |
| Test | Test | |||
| Test | Test | |||
| Test | ||||
| Test | Test | |||
| Test |


Participants:
Change the Shared Message & Item List :)
***This trial is bandwidth limited (per group limits).
The more you use the slower client synchronization becomes.
Register at www.zLineup.com to get a free Group-Share account.


Your first college home can be a taste of freedom and provide you with a great community, but the housing selection process can also be daunting. North by Northwestern's Freshman Housing Guide has you covered. Use the filters to see which buildings work for you, then click a building name to see video, photos and more.


Type the text of your choice in the textbox below. After doing this, or also while typing, choose the shift you want to use to cipher the text. More infos about the Caeser cipher are on its Wikipedia Page.
Made by @dervondenbergen This project is available on GitHub.


Onboarding
Compare By
Population
Fertility Rate
Health Expenses (%GDP)
Military Expenses (%GDP)
Education Expenses (%GDP)
About This Tool
View data source
NEA/SCA Home
NEA/SCA
Near East Asia (NEA)
South Central Asia (SCA)
Near East Asia Region
This tool uses data from the CIA World Factbook to compare different countries in your region.


[1] good price text-to-speech capability multiple via points along route Route Simulation is listed at 1 GB but has never calculated one trip correctly.
[2] each trip it was used ended in extra miles gas and maps fast recalculation of routes none so if text feature lack of competitors.


Using images in place of radio buttons
Accessibility Tests
Requirements:
- Do not use a mouse for this test.
- It is best to test in JAWS+IE or NVDA+FF.
- Test with keyboard only first.
- Retest with keyboard + screen reader.
Pass:
Keyboard only
- As I tab into the radio button cluster I can see a focus outline around the radio button with focus.
- As I use my space bar or my arrows to check/uncheck a particular radio button the state change is visually obvious.
Keyboard + screen reader
- As I tab into the radio button cluster I hear the legend describing what the radio buttons are for (JAWS/NVDA only).
- As each radio button receives focus I hear the label and the checked state of the radio button.
Fail:
Keyboard only
- When tabbing into a radio button cluster I do not see a focus outline around the radio button with focus.
- As I use my space bar or arrow keys to check/uncheck a particular radio button I can't visually tell whether it is in a checked or unchecked state.
Keyboard + screen reader
- I can't hear the legend and therefore do not know what this radio button cluster is for (JAWS/NVDA only).
- I cannot hear the label and the checked state of the radio buttons announced when it receives focus.
Three examples of radio buttons to test:
Typical radio button cluster
This is a fake link for focusing on.
Michelle's sample code
This is a fake link for focusing on.
Accessible solution for a graphical radio button
This is a fake link for focusing on.
Accessible Solution notes
- Radio buttons and labels are not moved off-screen.
- Radio buttons and labels are hidden behind icons.
- Fieldset and legend is used to give radio cluster meaning.
- I have hidden the legend from view while making sure it is announced by a screen reader.
- Label wraps around input field and icon, making the whole thing clickable.
- If a background image is used, the text behind will be seen in high-contrast mode.
- If SVGs are used (as shown) they will still be visible in high contrast mode.
- focus is placed around the icon using sibling selector.
- checked state color is assigned using sibling selector.


bool mail ( string $to , string $subject , string $message [, string $additional_headers [, string $additional_parameters ]] )
Sends an email.
Returns TRUE if the mail was successfully accepted for delivery, FALSE otherwise. It is important to note that just because the mail was accepted for delivery, it does NOT mean the mail will actually reach the intended destination.


{{!< ../layouts/starter-page.html}}
This is a basic starter page with charts.
pie chart
line chart
donut chart
bar chart


Toggle navigation
About
Meet the Board
Constituents
Calendar
Photo Gallery
Contact
PCUW Constituency
Welcome to the Penn Consortium of Undergraduate Women!
Join PCUW Steering! Applications will be out on April 1, 2015.
alpha Kappa Delta Phi


Extends the the Java™ Collections Framework by providing type-specific maps, sets, lists and priority queues with a small memory footprint and fast access and insertion; provides also big (64-bit) arrays, sets and lists, and fast, practical I/O classes for binary and text files. It is free software distributed under the Apache License 2.0.
fastutil
is formed by three cores:
The three cores are briefly introduced in the next sections, and then discussed at length in the rest of this overview.
The following features were added in version 8.5.0:
We strongly suggest to activate deprecation warnings in your development environment, as fastutil
systematically deprecates all JDK methods for which there is a type-specific alternative.
fastutil
specializes the most useful {@link
java.util.HashSet}, {@link java.util.HashMap}, {@link
java.util.LinkedHashSet}, {@link java.util.LinkedHashMap}, {@link
java.util.TreeSet}, {@link java.util.TreeMap}, {@link
java.util.IdentityHashMap}, {@link java.util.ArrayList} and {@link
java.util.Stack} classes to versions that accept a specific kind of
key or value (e.g., {@linkplain it.unimi.dsi.fastutil.ints.IntSet integers}). Besides, there are also
several types of {@linkplain it.unimi.dsi.fastutil.PriorityQueue priority
queues} and a large collection of static objects and
methods (such as {@linkplain it.unimi.dsi.fastutil.objects.ObjectSets#EMPTY_SET
immutable empty containers}, {@linkplain
it.unimi.dsi.fastutil.ints.IntComparators#OPPOSITE_COMPARATOR
comparators implementing the opposite of the natural order},
{@linkplain it.unimi.dsi.fastutil.ints.IntIterators#wrap(int[])
iterators obtained by wrapping an array} and so on).
To understand what's going on at a glance, the best thing is to look at the examples provided below. If you already used the Collections Framework, everything should look rather natural. If, in particular, you use an IDE such as Eclipse, which can suggest you the method names, all you need to know is the right name for the class you need.
A set of classes makes it possible to handle very large collections: in particular, collections whose size exceeds 231. {@linkplain it.unimi.dsi.fastutil.BigArrays Big arrays} are arrays-of-arrays handled by a wealth of static methods that act on them as if they were monodimensional arrays with 64-bit indices; {@linkplain it.unimi.dsi.fastutil.BigList big lists} provide 64-bit list access; {@linkplain it.unimi.dsi.fastutil.ints.IntOpenHashBigSet big hash sets} provide support for sets whose size is only limited by the amount of core memory.
The usual methods from {@link java.util.Arrays} and similar classes have been extended to big arrays: have a look at the Javadoc documentation of {@link it.unimi.dsi.fastutil.BigArrays} and {@link it.unimi.dsi.fastutil.ints.IntBigArrays} to get an idea of the generic and type-specific methods available.
Limited support is available for big atomic arrays of integers and longs.
fastutil
provides replacements for some standard classes of {@link java.io}
that are plagued by a number of problems (see, e.g., {@link it.unimi.dsi.fastutil.io.FastBufferedInputStream}).
The {@link it.unimi.dsi.fastutil.io.BinIO} and {@link it.unimi.dsi.fastutil.io.TextIO} static
containers contain dozens of methods that make it possible to load and save quickly
(big) arrays to disks, to adapt binary and text file to iterators, and so on.
All data structures in fastutil
extend their standard
counterpart interface whenever possible (e.g., {@link java.util.Map} for maps). Thus, they
can be just plugged into existing code, using the standard access methods
(of course, any attempt to use the wrong type for keys or values will
produce a {@link java.lang.ClassCastException}). However, they also provide
(whenever possible) many polymorphic versions of the most used methods that
avoid boxing/unboxing. In doing so, they specify more stringent interfaces that
extend and strengthen the standard ones (e.g., {@link
it.unimi.dsi.fastutil.ints.Int2IntSortedMap} or {@link
it.unimi.dsi.fastutil.ints.IntListIterator}). All generic methods
in type-specific interfaces have been deprecated.
Warning: automatic boxing and unboxing can lead you
to choose the wrong method when using fastutil
. It is also extremely inefficient.
We suggest that your programming environment is set so to mark boxing/unboxing as
a warning, or even better, as an error.
Of course, the main point of type-specific data structures is that the absence of wrappers around primitive types can increase speed and reduce space occupancy by several times. The presence of generics in Java does not change this fact, since there is no genericity for primitive types.
The implementation techniques used in fastutil
are quite
different than those of {@link java.util}: for instance, open-addressing
hash tables, threaded AVL trees, threaded red-black trees and exclusive-or
lists. An effort has also been made to provide powerful derived objects and
to expose them by overriding covariantly return types:
for instance, the {@linkplain it.unimi.dsi.fastutil.objects.Object2IntSortedMap#keySet() keys of sorted maps
are sorted} and iterators on sorted containers are always {@linkplain
it.unimi.dsi.fastutil.BidirectionalIterator bidirectional}.
More generally, the rationale behing fastutil
is that
you should never need to code explicitly natural
transformations. You do to not need to define an anonymous class to
iterate over an array of integers—just {@linkplain
it.unimi.dsi.fastutil.ints.IntIterators#wrap(int[]) wrap it}. You do not
need to write a loop to put the characters returned by an iterator into a
set—just {@linkplain
it.unimi.dsi.fastutil.chars.CharOpenHashSet#CharOpenHashSet(CharIterator)
use the right constructor}. And so on.
In general, class names adhere to the general pattern
for collections, and
for maps.
The word "type" here referes to a capitalized primitive type, {@link
java.lang.Object} or Reference
. In the latter case, we
are treating objects, but their equality is established by reference
equality (that is, without invoking equals()
), similarly
to {@link java.util.IdentityHashMap}. Of course, reference-based
classes are significantly faster.
Thus, an {@link it.unimi.dsi.fastutil.ints.IntOpenHashSet} stores integers efficiently and implements {@link it.unimi.dsi.fastutil.ints.IntSet}, whereas a {@link it.unimi.dsi.fastutil.longs.Long2IntAVLTreeMap} does the same for maps from longs to integers (but the map will be sorted, tree based, and balanced using the AVL criterion), implementing {@link it.unimi.dsi.fastutil.longs.Long2IntMap}. If you need additional flexibility in choosing your {@linkplain it.unimi.dsi.fastutil.Hash.Strategy hash strategy}, you can put, say, arrays of integers in a {@link it.unimi.dsi.fastutil.objects.ObjectOpenCustomHashSet}, maybe using the ready-made {@linkplain it.unimi.dsi.fastutil.ints.IntArrays#HASH_STRATEGY hash strategy for arrays}. A {@link it.unimi.dsi.fastutil.longs.LongLinkedOpenHashSet} stores longs in a hash table, but provides a predictable iteration order (the insertion order) and access to first/last elements of the order. A {@link it.unimi.dsi.fastutil.objects.Reference2ReferenceOpenHashMap} is similar to an {@link java.util.IdentityHashMap}. You can manage a priority queue of characters in a heap using a {@link it.unimi.dsi.fastutil.chars.CharHeapPriorityQueue}, which implements {@link it.unimi.dsi.fastutil.chars.CharPriorityQueue}. {@linkplain it.unimi.dsi.fastutil.bytes.ByteArrayFrontCodedList Front-coded lists} are highly specialized immutable data structures that store compactly a large number of arrays: if you don't know them you probably don't need them.
For a number of data structures that were not available in the
Java™ Collections Framework
when fastutil
was created, an object-based version is
contained in {@link it.unimi.dsi.fastutil}, and in that case the prefix
Object
is not used (see, e.g., {@link it.unimi.dsi.fastutil.PriorityQueue}).
Since there are eight primitive types in Java, and we support
reference-based containers, we get around 2000 (!) classes (some nonsensical
classes, such as Boolean2BooleanAVLTreeMap
, are not
generated). Many classes are generated just to mimic the hierarchy of
{@link java.util} so to redistribute common code in a similar way. There
are also several abstract classes that ease significantly the creation of
new type-specific classes by providing automatically generic methods based
on the type-specific ones.
The huge number of classes required a suitable division in subpackages.
Each subpackage is characterized by the type of elements
or keys: thus, for instance, {@link it.unimi.dsi.fastutil.ints.IntSet}
belongs to {@link it.unimi.dsi.fastutil.ints} (the plural is required, as
int
is a keyword and cannot be used in a package name), as
well as {@link it.unimi.dsi.fastutil.ints.Int2ReferenceRBTreeMap}. Note
that all classes for non-primitive elements and keys are gathered in {@link
it.unimi.dsi.fastutil.objects}. Finally, a number of non-type-specific
classes have been gathered in {@link it.unimi.dsi.fastutil}.
The following table summarizes the available interfaces and implementations. To get more information, you can look at a specific implementation in {@link it.unimi.dsi.fastutil} or, for instance, {@link it.unimi.dsi.fastutil.ints}. Note that a few existing abstract classes have been deprecated and are not listed here (they are no longer necessary due to default methods in the corresponding interfaces).
| Interfaces | Abstract Implementations | Implementations |
|---|---|---|
| Iterable | ||
| Collection | AbstractCollection | |
| Set | AbstractSet | OpenHashSet, OpenCustomHashSet, ArraySet, OpenHashBigSet |
| SortedSet | AbstractSortedSet | RBTreeSet, AVLTreeSet, LinkedOpenHashSet |
| Function | AbstractFunction | |
| Map | AbstractMap | OpenHashMap, OpenCustomHashMap, ArrayMap |
| SortedMap | AbstractSortedMap | RBTreeMap, AVLTreeMap, LinkedOpenHashMap |
| List, BigList† | AbstractList, AbstractBigList | ArrayList, BigArrayBigList, ArrayFrontCodedList, ImmutableList |
| PriorityQueue† | HeapPriorityQueue, ArrayPriorityQueue, ArrayFIFOQueue | |
| IndirectPriorityQueue† | HeapSemiIndirectPriorityQueue, HeapIndirectPriorityQueue, ArrayIndirectPriorityQueue | |
| Stack† | ArrayList | |
| Pair† | MutablePair, ImmutablePair | |
| Iterator, BigListIterator† | Iterators.AbstractIndexBasedIterator | |
| Spliterator | Spliterators.AbstractIndexBasedSpliterator | |
| Comparator | ||
| BidirectionalIterator† | ||
| ListIterator | ||
| Consumer | ||
| Predicate | ||
| BinaryOperator | ||
| Size64‡ |
†: this class has also a non-type-specific implementation in {@link it.unimi.dsi.fastutil}.
‡: this class has only a non-type-specific implementation in {@link it.unimi.dsi.fastutil}.
Note that abstract implementations are named by prefixing the interface name with Abstract. Thus, if you want to define a type-specific structure holding a set of integers without the hassle of defining object-based methods, you should inherit from {@link it.unimi.dsi.fastutil.ints.AbstractIntSet}.
The following table summarizes static containers, which usually give rise both to a type-specific and to a generic class:
| Static Containers |
|---|
| Collections |
| Sets |
| SortedSets |
| Functions |
| Maps† |
| SortedMaps |
| Lists |
| BigLists |
| Arrays† |
| BigArrays† |
| Heaps |
| SemiIndirectHeaps |
| IndirectHeaps |
| PriorityQueues† |
| IndirectPriorityQueues† |
| Iterators |
| BigListIterators |
| Spliterators |
| BigSpliterators |
| Comparators |
| Hash‡ |
| HashCommon‡ |
| SafeMath‡ |
†: this class has also a non-type-specific implementation in {@link it.unimi.dsi.fastutil}.
‡: this class has only a non-type-specific implementation in {@link it.unimi.dsi.fastutil}.
The static containers provide also special-purpose implementations for all kinds of {@linkplain it.unimi.dsi.fastutil.objects.ObjectSets#EMPTY_SET empty structures} (including {@linkplain it.unimi.dsi.fastutil.objects.ObjectArrays#EMPTY_ARRAY arrays}) and {@linkplain it.unimi.dsi.fastutil.ints.Int2IntMaps#singleton(int,int) singletons}.
All classes are not synchronized. If multiple threads access one of these classes concurrently, and at least one of the threads modifies it, it must be synchronized externally. Iterators will behave unpredictably in the presence of concurrent modifications. Reads, however, can be carried out concurrently.
Reference-based classes violate the {@link java.util.Map}
contract. They intentionally compare objects by reference, and do
not use the equals()
method. They should be used only
when reference-based equality is desired (for instance, if all
objects involved are canonized, as it happens with interned strings).
Setting the default return value for maps with both non-primitive
keys and non-primitive values violates the {@link java.util.Map} contract, as you
might not get null
on missing keys.
Linked classes do not implement wholly the {@link java.util.SortedMap} interface. They provide methods to get the first and last element in iteration order, and to start a bidirectional iterator from any element, but any submap or subset method will cause an {@link java.lang.UnsupportedOperationException} (this may change in future versions).
Substructures in sorted classes allow the creation of
arbitrary substructures. In {@link java.util}, instead, you
can only create contained sub-substructures (BTW, why?). For instance,
(new TreeSet()).tailSet(1).tailSet(0)
will throw an exception,
but {@link it.unimi.dsi.fastutil.ints.IntRBTreeSet (new
IntRBTreeSet()).tailSet(1).tailSet(0)} won't.
The new interfaces add some very natural methods and strengthen many of the old ones. Moreover, whenever possible, the object returned is type-specific, or implements a more powerful interface.
More in detail:
fastutil
type you
would expect (e.g., the keys of an {@link
it.unimi.dsi.fastutil.ints.Int2LongSortedMap} are an {@link
it.unimi.dsi.fastutil.ints.IntSortedSet} and the values are a {@link
it.unimi.dsi.fastutil.longs.LongCollection}).
addTo()
method (see, e.g., {@link it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap#addTo(int,int)})
that adds an increment to the current value of a key; it is
most useful to avoid the inefficient procedure of getting a value,
incrementing it and then putting it back into the map (typically, when
counting the number of occurrences of elements in a sequence).
fastutil
type you would expect, too.
iterator()
are type-specific.
spliterator()
are type-specific.
fastutil
return
type-specific {@linkplain
it.unimi.dsi.fastutil.BidirectionalIterator bidirectional
iterators}. This means that you can move back and forth among
entries, keys or values.
for
loops, there are static helper methods available
(e.g., {@link it.unimi.dsi.fastutil.ints.Int2IntMaps#fastIterable(it.unimi.dsi.fastutil.ints.Int2IntMap)}).
iterator(from)
which creates a type-specific {@link
it.unimi.dsi.fastutil.BidirectionalIterator} starting from a given
element of the domain (not necessarily in the set). See, for instance,
{@link it.unimi.dsi.fastutil.ints.IntSortedSet#iterator(int)}. The method is
implemented by all type-specific sorted sets and subsets.
new ObjectOpenHashSet( new String[] { "foo", "bar" } )
or just "unroll" the integers returned by an iterator into a list with
new IntArrayList( iterator )
There are a few quirks, however, that you should be aware of:
null
to denote the absence of a certain
pair. Rather, they return a {@linkplain
it.unimi.dsi.fastutil.ints.Int2LongMap#defaultReturnValue(long) default
return value}, which is set to 0 cast to the
return type (false
for booleans) at creation, but
can be changed using the defaultReturnValue()
method (see, e.g., {@link
it.unimi.dsi.fastutil.ints.Int2IntMap}). Note that changing the
default return value does not change anything about the data
structure; it is just a way to return a reasonably meaningful
result—it can be changed at any time. For uniformity reasons,
even maps returning objects can use
defaultReturnValue()
(of course, in this case the
default return value is initialized to null
). A
submap or subset has an independent default return value (which
however is initialized to the default return value of the
originator).fastutil
's
type-specific {@code next()}/{@code previous()} methods.
rem()
on variables that are collections, but not
sets—for instance, {@linkplain
it.unimi.dsi.fastutil.ints.IntList type-specific lists}, and
that a subclass of a type-specific abstract collection must
override rem()
, rather than remove()
, to
make all inherited methods work properly.fastutil
tries to extend such interfaces (e.g.,
{@link it.unimi.dsi.fastutil.ints.IntIterator} extends
{@link java.util.PrimitiveIterator.OfInt}).fastutil
correct type-specific version, but, as in the previous case,
the fastutil
version extends the closest {@link java.util.function.Consumer}.
For example, {@link it.unimi.dsi.fastutil.chars.CharConsumer} extends
{@link java.util.function.IntConsumer}.fastutil
provides interfaces, abstract implementations and the usual array of wrappers
in the suitable static container (e.g., {@link it.unimi.dsi.fastutil.ints.Int2IntFunctions}).
Implementations will be provided by other projects (e.g., Sux4J).
Type-specific functions require just to define their {@code get()} methods: thus, they can be defined
by lambda expressions.
All fastutil
type-specific maps extend their respective type-specific
functions: but, alas, we cannot have {@link java.util.Map} extending
{@link it.unimi.dsi.fastutil.Function}. Moreover, type-specific
functions extend the existing type-specific function from {@link
java.util.function} that can accommodate the argument and the result with the least
widening: for example, {@link
it.unimi.dsi.fastutil.shorts.Short2CharFunction} extends {@link
java.util.function.IntUnaryOperator}.
fastutil
provides a number of static methods and
singletons, much like {@link java.util.Collections}. To avoid creating
classes with hundreds of methods, there are separate containers for
sets, lists, maps and so on. Generic containers are placed in {@link
it.unimi.dsi.fastutil}, whereas type-specific containers are in the
appropriate package. You should look at the documentation of the
static classes contained in {@link it.unimi.dsi.fastutil}, and in
type-specific static classes such as {@link
it.unimi.dsi.fastutil.chars.CharSets}, {@link
it.unimi.dsi.fastutil.floats.Float2ByteSortedMaps}, {@link
it.unimi.dsi.fastutil.longs.LongArrays}, {@link
it.unimi.dsi.fastutil.floats.FloatHeaps}. Presently, you can easily
obtain {@linkplain it.unimi.dsi.fastutil.objects.ObjectSets#EMPTY_SET empty collections},
{@linkplain it.unimi.dsi.fastutil.longs.Long2IntMaps#EMPTY_MAP empty
type-specific collections}, {@linkplain
it.unimi.dsi.fastutil.ints.IntLists#singleton(int) singletons},
{@linkplain
it.unimi.dsi.fastutil.objects.Object2ReferenceSortedMaps#synchronize(Object2ReferenceSortedMap)
synchronized versions} of any type-specific container and
unmodifiable versions of {@linkplain
it.unimi.dsi.fastutil.objects.ObjectLists#unmodifiable(ObjectList)
containers} and {@linkplain
it.unimi.dsi.fastutil.ints.IntIterators#unmodifiable(IntBidirectionalIterator) iterators} (of course,
unmodifiable containers always return unmodifiable iterators).
On a completely different side, the {@linkplain it.unimi.dsi.fastutil.ints.IntArrays type-specific static container classes for arrays} provide several useful methods that allow to treat an array much like an array-based list, hiding completely the growth logic. In many cases, using this methods and an array is even simpler then using a full-blown {@linkplain it.unimi.dsi.fastutil.doubles.DoubleArrayList type-specific array-based list} because elements access is syntactically much simpler. The version for objects uses reflection to return arrays of the same type of the argument.
For the same reason, fastutil
provides a full
implementation of methods that manipulate arrays as type-specific
{@linkplain it.unimi.dsi.fastutil.ints.IntHeaps heaps}, {@linkplain
it.unimi.dsi.fastutil.ints.IntSemiIndirectHeaps semi-indirect heaps} and
{@linkplain it.unimi.dsi.fastutil.ints.IntIndirectHeaps indirect heaps}. There are
also quicksort and mergesort implementations that use arbitrary type-specific comparators.
fastutil
offers also a less common choice—a very tuned
implementation of {@linkplain it.unimi.dsi.fastutil.ints.IntArrays#radixSort(int[],int,int) radix sort} for
all primitive types. It is significantly faster than quicksort already at small sizes (say, more than 10000 elements), and should
be considered the sorting algorithm of choice if you do not need a generic comparator.
There are several variants provided. First of all you can radix sort in parallel {@linkplain it.unimi.dsi.fastutil.ints.IntArrays#radixSort(int[],int[], int, int) two} or {@linkplain it.unimi.dsi.fastutil.ints.IntArrays#radixSort(int[][],int,int) even more} arrays. You can also perform {@linkplain it.unimi.dsi.fastutil.ints.IntArrays#radixSortIndirect(int[],int[],int,int,boolean) indirect} sorts, for instance if you want to compute the sorting permutation of an array.
The sorting algorithm is a tuned radix sort adapted from Peter M. McIlroy, Keith Bostic and M. Douglas McIlroy, “Engineering radix sort”, Computing Systems, 6(1), pages 5−27 (1993), and further improved using the digit-oracle idea described by Juha Kärkkäinen and Tommi Rantala in “Engineering radix sort for strings”, String Processing and Information Retrieval, 15th International Symposium, volume 5280 of Lecture Notes in Computer Science, pages 3−14, Springer (2008). The basic algorithm is not stable, but this is immaterial for arrays of primitive types. For the indirect case, there is a parameter specifying whether the algorithm should be stable.
fastutil
provides type-specific iterators and
comparators. The interface of a fastutil
iterator is
slightly more powerful than that of a {@link java.util} iterator, as
it contains a {@link it.unimi.dsi.fastutil.objects.ObjectIterator#skip(int)
skip()} method that allows to skip over a list of elements (an
{@linkplain
it.unimi.dsi.fastutil.objects.ObjectBidirectionalIterator#back(int) analogous
method} is provided for bidirectional iterators). For objects (even
those managed by reference), the extended interface is named {@link
it.unimi.dsi.fastutil.objects.ObjectIterator}; it is the return type, for
instance, of {@link
it.unimi.dsi.fastutil.objects.ObjectCollection#iterator()}.
A plethora of useful static methods is also provided by various type-specific static containers (e.g., {@link it.unimi.dsi.fastutil.ints.IntIterators}) and {@link it.unimi.dsi.fastutil.ints.IntComparators}: among other things, you can {@linkplain it.unimi.dsi.fastutil.ints.IntIterators#wrap(int[]) wrap arrays} and {@linkplain it.unimi.dsi.fastutil.ints.IntIterators#asIntIterator(java.util.Iterator) standard iterators} in type-specific iterators, {@linkplain it.unimi.dsi.fastutil.ints.IntIterators#fromTo(int,int) generate them} giving an interval of elements to be returned, {@linkplain it.unimi.dsi.fastutil.objects.ObjectIterators#concat(ObjectIterator[]) concatenate them} or {@linkplain it.unimi.dsi.fastutil.objects.ObjectIterators#pour(Iterator,ObjectCollection) pour them} into a set.
fastutil
provides type-specific {@linkplain java.util.Spliterator spliterators}. These are
used to implement fast streams.
Due to Java only supporting primitive Streams of int
, long
,
and double
,
types for primitives narrower then that (such as {@linkplain
it.unimi.dsi.fastutil.bytes.ByteCollection ByteCollection}) have methods
that expose a spliterator widening them to the type supported by the
Stream API. For example, {@linkplain it.unimi.dsi.fastutil.bytes.ByteCollection ByteCollection}
will have an {@link it.unimi.dsi.fastutil.bytes.ByteCollection#intSpliterator intSpliterator()}
method in addition to a spliterator()
method that works in terms of
bytes.
Due to the incompatibility of object based {@linkplain java.util.stream.Stream streams} and the
primitive streams (such as {@link java.util.stream.IntStream}), the stream()
methods of the primitive containers could not be updated to return their
primitive equivalents. Instead, for primitive collections, a new method is
provided that exposes a primitive stream, and the object based stream method
is marked deprecated like the other boxing methods do.
For example, {@linkplain it.unimi.dsi.fastutil.bytes.ByteCollection},
{@linkplain it.unimi.dsi.fastutil.shorts.ShortCollection}, and
{@linkplain it.unimi.dsi.fastutil.ints.IntCollection} exposes an
{@link it.unimi.dsi.fastutil.ints.IntCollection#intStream() intStream()} method, which should
be used in preference to
stream()
as it will not box and unbox.
Since type-specific {@link java.util.stream.Collector collectors} would be
more than 700, fastutil
implements basic collection
methods in each container (e.g., {@link
it.unimi.dsi.fastutil.ints.IntImmutableList#toList(java.util.stream.IntStream)
IntImmutableList.toList()}). These methods must be applied to a stream
to obtain a collection containing the output of the stream.
Similar to iterators, a raft of utility methods for type-specific spliterators are provided
(e.g. {@link it.unimi.dsi.fastutil.ints.IntSpliterators}). Most of them are analogues of the
utilities in the type-specific Iterators
class.
Currently no utility methods are provided for type-specific streams, as the Java library's API already has good coverage for that (e.g. the static methods of {@link java.util.stream.Stream} and their primitive equivalents, or classes such as {@link java.util.stream.StreamSupport}).
Classes such as {@link java.util.function.IntBinaryOperator} were introduced in Java 8
to obtain performance improvements similar to those obtained by fastutil
. Unfortunately,
the design of all these classes follows an opposite choice with respect to fastutil
's:
type-specific classes do not extend the generic ones. Moreover, type specificity is rather limited
(e.g., there are no short-specific classes). The fact that type-specific classes do not extend
generic ones makes it difficult to use lambdas, as often they are (rightly) considered
ambiguous by the compiler. The solution implemented in fastutil
8.5.0 is to have
an internal type-specific version of these interfaces which extends both the generic one
and the JDK type-specific one, allowing also for type widening (e.g., {@link it.unimi.dsi.fastutil.chars.CharConsumer}
extends {@link java.util.function.IntConsumer}). When definining lambdas, the compiler now
has a more specific type to choose (the type-specific fastutil
interface), and
no ambiguity arises.
fastutil
offers two types of queues: direct
queues and indirect queues. A direct queue offers type-specific method to {@linkplain
it.unimi.dsi.fastutil.longs.LongPriorityQueue#enqueue(long) enqueue} and
{@linkplain it.unimi.dsi.fastutil.longs.LongPriorityQueue#dequeueLong()
dequeue} elements. An indirect queue needs a reference array,
specified at construction time: {@linkplain
it.unimi.dsi.fastutil.IndirectPriorityQueue#enqueue(int) enqueue} and
{@linkplain it.unimi.dsi.fastutil.IndirectPriorityQueue#dequeue()
dequeue} operations refer to indices in the reference array. The advantage
is that it may be possible to {@linkplain
it.unimi.dsi.fastutil.IndirectPriorityQueue#changed(int) notify the change}
of any element of the reference array, or even to {@linkplain
it.unimi.dsi.fastutil.IndirectPriorityQueue#remove(int) remove an arbitrary
element}.
Queues have two kind of implementations: array-based implementations, and heap-based implementations. In particular, heap-based indirect queues may be {@linkplain it.unimi.dsi.fastutil.objects.ObjectHeapIndirectPriorityQueue fully indirect} or just {@linkplain it.unimi.dsi.fastutil.objects.ObjectHeapSemiIndirectPriorityQueue semi-indirect}: in the latter case, there is no need for an explicit indirection array (which saves one integer per queue entry), but not all operations will be available. Note there there are also {@linkplain it.unimi.dsi.fastutil.ints.IntArrayFIFOQueue FIFO queues}.
Sometimes, the behaviour of the built-in equality and hashing methods is
not what you want. In particular, this happens if you store in a hash-based
collection arrays, and you would like to compare them by equality. For this kind of applications,
fastutil
provides {@linkplain it.unimi.dsi.fastutil.Hash.Strategy custom hash strategies},
which define new equality and hashing methods to be used inside the collection. There are even
{@linkplain it.unimi.dsi.fastutil.ints.IntArrays#HASH_STRATEGY ready-made strategies} for arrays. Note, however,
that fastutil
containers do not cache hash codes, so custom hash strategies must be efficient.
fastutil
provides a wide range of abstract classes, to
help in implementing its interfaces. They take care, for instance, of
providing wrappers for non-type-specific method calls, so that you have to
write just the (usually simpler) type-specific version. When possible,
such wrappers are actually default methods, so no abstract class is
necessary.
With the continuous increase in core memory available, Java arrays are starting to show
their size limitation (indices cannot be larger than 231). fastutil
proposes to store big arrays using arrays-of-arrays subject to certain
size restrictions and a number of supporting static methods. Please read the documentation
of {@link it.unimi.dsi.fastutil.BigArrays} to understand how big arrays work.
Correspondingly, fastutil
proposes a new interface, called
{@link it.unimi.dsi.fastutil.Size64}, that should be implemented by very large
collections. {@link it.unimi.dsi.fastutil.Size64} contains a method
{@link it.unimi.dsi.fastutil.Size64#size64()} which returns the collection
size as a long integer.
fastutil
provides {@linkplain it.unimi.dsi.fastutil.BigList big lists},
which are lists with 64-bit indices; of course, they implement {@link it.unimi.dsi.fastutil.Size64}.
An implementation based on big arrays is provided (see, e.g., {@link it.unimi.dsi.fastutil.ints.IntBigArrayBigList}),
as well as static containers (see, e.g., {@link it.unimi.dsi.fastutil.ints.IntBigLists}).
Whereas it is unlikely that such collection will be in main memory as big arrays, there
are number of situations, such as exposing large files through a list interface or
storing a large amount of data using succinct data structures,
in which a big list interface is natural.
Unfortunately, {@linkplain java.util.List lists} and {@linkplain it.unimi.dsi.fastutil.BigList big lists}, as well as {@linkplain java.util.ListIterator list iterators} and {@linkplain it.unimi.dsi.fastutil.BigListIterator big-list iterators}, cannot be made compatible: we thus provide adapters (see, e.g., {@link it.unimi.dsi.fastutil.ints.IntBigLists#asBigList(it.unimi.dsi.fastutil.ints.IntList)}).
Finally, fastutil
provides {@linkplain it.unimi.dsi.fastutil.longs.LongOpenHashBigSet big hash sets}, which
are based on big arrays. They are about 30% slower than non-big sets, but their size is limited only by
the amount core memory.
fastutil
includes an {@linkplain
it.unimi.dsi.fastutil.io I/O package} that provides, for instance, {@linkplain
it.unimi.dsi.fastutil.io.FastBufferedInputStream fast, unsynchronized
buffered input streams}, {@linkplain
it.unimi.dsi.fastutil.io.FastBufferedOutputStream fast, unsynchronized
buffered output streams}, and a wealth of static methods to store and
retrieve data in {@linkplain it.unimi.dsi.fastutil.io.TextIO textual} and
{@linkplain it.unimi.dsi.fastutil.io.BinIO binary} form. The latter, in particular,
contain methods that load and store big arrays.
The main reason behind fastutil
is performance, both in
time and in space. The relevant methods of type-specific hash maps and sets
are something like 2 to 10 times faster than those of the standard
classes. Note that performance of hash-based classes on object keys is
usually slightly worse than that of
{@link java.util}, because fastutil
classes do not cache hash
codes (albeit it will not be that bad if keys cache internally hash codes,
as in the case of {@link java.lang.String}). Of course, you can try to get
more speed from hash tables using a small load factor: to this purpose,
alternative load factors are proposed in {@link it.unimi.dsi.fastutil.Hash#FAST_LOAD_FACTOR}
and {@link it.unimi.dsi.fastutil.Hash#VERY_FAST_LOAD_FACTOR}.
For tree-based classes you have two choices: AVL and red-black trees. The essential difference is that AVL trees are more balanced (their height is at most 1.44 log n), whereas red-black trees have faster deletions (but their height is at most 2 log n). So on small trees red-black trees could be faster, but on very large sets AVL trees will shine. In general, AVL trees have slightly slower updates but faster searches; however, on very large collections the smaller height may lead in fact to faster updates, too.
fastutil
reduces enormously the creation and collection of
objects. First of all, if you use the polymorphic methods and iterators no
wrapper objects have to be created. Moreover, since fastutil
uses open-addressing hashing techniques, creation and garbage collection of
hash-table entries are avoided (but tables have to be rehashed whenever
they are filled beyond the load factor). The major reduction of the number
of objects around has a definite (but very difficult to measure) impact on
the whole application (as garbage collection runs proportionally to the
number of alive objects).
Maps whose iteration is very expensive in terms of object creation (e.g., hash-based classes) usually return a type-specific {@link it.unimi.dsi.fastutil.ints.Int2IntMap.FastEntrySet FastEntrySet} whose {@link it.unimi.dsi.fastutil.ints.Int2IntMap.FastEntrySet#fastIterator() fastIterator()} method significantly reduces object creation by returning always the same entry object, suitably mutated.
The absence of wrappers makes data structures in fastutil
much smaller: even in the case of objects, however, data structures in
fastutil
try to be space-efficient.
To avoid memory waste, (unlinked) hash tables in
fastutil
keep no additional information about elements
(such as a list of keys). In particular, this means that enumerations
are always linear in the size of the table (rather than in the number
of keys). Usually, this would imply slower iterators. Nonetheless, the
iterator code includes a single, tight loop; moreover, it is possible
to avoid the creation of wrappers. These two facts make in practice
fastutil
iterators faster than {@link
java.util}'s.
The memory footprint for a table of length ℓ is exactly the memory required for the related types times ℓ. The absence of wrappers around primitive types can reduce space occupancy by several times (this applies even more to serialized data, e.g., when you save such a data structure in a file). These figures can greatly vary with your virtual machine, JVM versions, CPU etc.
More precisely, when you ask for a map that will hold n elements with load factor 0 < f < 1, 2⌈log n / f⌉ entries are allocated. When the table is filled up beyond the load factor, it is rehashed doubling its size. When it is emptied below one fourth of the load factor, it is rehashed halving its size; however, a map is never reduced to a size smaller than that at creation time: this approach makes it possible to create maps with a large capacity in which insertions and deletions do not cause immediately rehashing.
In the case of linked hash tables, there is an additional vector of 2⌈log n / f⌉ longs that is used to store link information. Each element records the next and previous element (packed together so to be more cache friendly).
The balanced trees implementation is also very parsimonious.
fastutil
is based on the excellent (and unbelievably well
documented) code contained in Ben Pfaff's GNU libavl, which describes in
detail how to handle balanced trees with threads. Thus, the
overhead per entry is two pointers and one integer, which compares well to
three pointers plus one boolean of the standard tree maps. The trick is
that we use the integer bit by bit, so we consume two bits to store thread
information, plus one or two bits to handle balancing. As a result, we get
bidirectional iterators in constant space and amortized constant time
without having to store references to parent nodes.
It should be mentioned that all tree-based classes have a fixed overhead for some arrays that are used as stacks to simulate recursion; in particular, we need 48 booleans for AVL trees and 64 pointers plus 64 booleans for red-black trees.
To store a set of longs, we can use a hash-based container:
LongSet s = new LongOpenHashSet();
Access methods avoid boxing and unboxing:
s.add(1); s.contains(2);
We can obtain a type-specific iterator on the elements of the set:
// Sum all elements long t = 0; for(LongIterator i = s.iterator(); i.hasNext();) t += i.nextLong();
Note that “for each” iteration must be avoided:
long t = 0; for(long x: s) t += x;
In the loop above, boxing and unboxing is happening (even if your IDE does not report it). In some cases, a solution is to use a type-specific {@link java.util.Collection#forEach(java.util.function.Consumer) forEach()}:
// Print all elements s.forEach(x -> System.out.println(x));
Or we can use fastutil
's type-specific version of Java 8's streams:
long t = m.longStream().sum();
Suppose instead you want to store a sorted map from longs to integers. We will use a tree of AVL type:
Long2IntSortedMap m = new Long2IntAVLTreeMap();
Now we can easily modify and access its content:
m.put(1, 5); m.put(2, 6); m.put(3, 7); m.put(1000000000L, 10); m.get(1); // This method call will return 5 m.get(4); // This method call will return 0
We can also try to change the default return value:
m.defaultReturnValue(-1); m.get(4); // This method call will return -1
We can obtain a type-specific iterator on the key set:
LongBidirectionalIterator i = m.keySet().iterator(); // Now we sum all keys long s = 0; while(i.hasNext()) s += i.nextLong();
Or we can use again fastutil
's type-specific version of Java 8's streams:
long s = m.longStream().sum();
We now generate a head map, and iterate bidirectionally over it starting from a given point:
// This map contains only keys smaller than 4 Long2IntSortedMap m1 = m.headMap(4); // This iterator is positioned between 2 and 3 LongBidirectionalIterator t = m1.keySet().iterator(2); t.previous(); // This method call will return 2 (t.next() would return 3)
Should we need to access the map concurrently, we can wrap it:
// This map can be safely accessed by many threads Long2IntSortedMap m2 = Long2IntSortedMaps.synchronize(m1);
Linked maps are very flexible data structures which can be used to implement, for instance, queues whose content can be probed efficiently:
// This map remembers insertion order. IntSortedSet s = new IntLinkedOpenHashSet.of(4, 3, 2, 1); s.firstInt(); // This method call will return 4 s.lastInt(); // This method call will return 1 s.contains(5); // This method will return false IntBidirectionalIterator i = s.iterator(s.lastInt()); // We could even cast it to a list iterator i.previous(); // This method call will return 1 i.previous(); // This method call will return 2 s.remove(s.lastInt()); // This will remove the last element in constant time
Now, we play with iterators. It is easy to create iterators over intervals or over arrays, and combine them:
IntIterator i = IntIterators.fromTo(0, 10); // This iterator will return 0, 1, ..., 9 int[] a = new int[] { 5, 1, 9 }; IntIterator j = IntIterators.wrap(a); // This iterator will return 5, 1, 9. IntIterator k = IntIterators.concat(new IntIterator[] { i , j }); // This iterator will return 0, 1, ..., 9, 5, 1, 9
It is easy to build lists and sets on the fly using the {@code of} static factory methods. For maps you can use the constructors that take key and value arrays (array based constructors for list and set exist too):
IntSet s = IntOpenHashSet.of(1, 2, 3); // This set will contain 1, 2, and 3 Char2IntMap m = new Char2IntRBTreeMap(new char[] { '@', '-' }, new int[] { 0, 1 }); // This map will map '@' to 0 and '-' to 1
Whenever you have some data structure, it is easy to serialize it in an efficient (buffered) way, or to dump their content in textual form:
BinIO.storeObject(s, "foo"); // This method call will save s in the file named "foo" TextIO.storeInts(s.intIterator(), "foo.txt"); // This method call will save the content of s in ASCII i = TextIO.asIntIterator("foo.txt"); // This iterator will parse the file and return the integers therein
Support for Java 8 primitive streams is included for primitive collections (e.g. {@code intStream}), which will work in terms of primitives instead of boxing to wrapper types like the regular {@code stream} would do:
IntList l = IntList.of(2, 380, 1297); int lSum = l.intStream().sum(); // Will be 1679 IntList lTransformed = IntArrayList.toList(l.intStream().map(i -> i + 40)); // Will be 42, 420, 1337
You can sort arrays using type-specific comparators specified by lambda expressions (no boxing/unboxing here):
IntArrays.quickSort(a, (x, y) -> Integer.compare(y, x)); // Sorts in reverse order
You can also easily specify complex generic sorting, like sorting indirectly on {@code a} while swapping elements in {@code a} and {@code b} in parallel:
Arrays.quickSort(0, a.length, (i, j) -> Integer.compare(a[i], a[j]), (i, j) -> { IntArrays.swap(a, i, j); IntArrays.swap(b, i, j); }));
If you have several cores, you can do it in parallel:
IntArrays.parallelQuickSort(a, (x, y) -> y - x); // Sorts in reverse order Arrays.parallelQuickSort(0, a.length, (i, j) -> Integer.compare(a[i], a[j]), (i, j) -> { IntArrays.swap(a, i, j); IntArrays.swap(b, i, j); }));
Some maps provide a fast iterator on their entry set: such iterators are allowed to reuse the {@link java.util.Map.Entry} instance they return, resulting is highly reduced garbage collection (e.g., for large hash maps). To easily access such iterators, we can use a helper static method:
Int2IntOpenHashMap m = new Int2IntOpenHashMap(); // Fill the map for (Int2IntMap.Entry e : Int2IntMaps.fastIterable(m)) { // do things with e.getIntKey() and e.getIntValue(); }
The code above will not generate an object per enumerated item, as for(Entry<Integer,Integer> e: m.entrySet())
(or even for(Int2IntMap.Entry e: m.int2IntKeySet())
) would do.


00
:
00
:
00
Try again?
Implementation
Dynamic Programming
Graphs
Recursion
Greedy
Binary Search
TBD


|
Contributors
- James Clark:
- The father of Jade. James made
the first version called Jade. He was
instrumental to the idea of a single set of flow
objects and multiple backend formats. James
carried the Jade project for several years until
it became a group project and got renamed
OpenJade. He is no longer participating to the
OpenJade project but his spirit still and will
always remain with us. He created most of the
Openjade code and the SGML/XML and the RTF
backends. But it is shorter to tell what he didn't
do than what he did :-)
- Matthias Clasen:
- I am an old-time LaTeX user
and a scheme lover. My first jade hacking
experience was trying to use dsssl to produce
properly formatted indexes, realizing the need
for language-dependent string sorting. That code
is now part of OpenJade. Since I think that the
full power of DSSSL can only be explored with a
reasonably complete implementation, I am working
to fill the gaps in jade's coverage of the
standard.
- Avi Kivity:
- I stumbled on Jade after
attempts to format SGML documents using C++
proved too cumbersome. I was impressed by the
power of DSSSL and the functional programming
style, which I hadn't used before. My main
interest is fully-integrated backends; that is,
formatters which do the layout themselves and do
not depend on external layout engines like TeX or
Word. I also maintain the CVS repository and
perform builds and releases.
- Didier PH Martin:
- I encountered Jade simply by
browsing to find new ways to process XML/SGML
documents. I had to learn it without a book and
with minimal documentation. The more I know about
this environment the more I learn to appreciate
it. This is why, I am a fervant advocate of DSSSL,
OpenJade and work hard to provide to members of
the OpenJade community, a rich environment, an
adequate documentation, a future to this language.
After more than 20 years in
the computer business, I still enjoy creating and
learning. As a canadian member of the ISO
Document Description and Processing Languages
comittee, my goal is to make a DSSSL-2 possible
reality.
- Peter Nilsson:
- The man behind braifo.
- Sebastian Ratz:
- You have a question about Tex?
Sebastian is the right guy to answer to your question. He
created the Tex backend processor with David and Kathleen.
- Kathleen Marszalek:
- She is the bee, working
hard and methodical. She created the Tex and MIF backends
with other members of the team.
- Paul Prescod:
- Paul has always a good
comment to bring to the table. He created the MIF backend
with Kathleen.
- David Megginson:
- An other fellow canadian
that is bringing every day to the XML community ideas,
new code, its commitment. He created the Tex backend with
Kathleen and Sebastian.
|


GELATO HOMECARE VIVID NEUTRAL- sodium fluoride gel
Mycone Dental Supply Co., Inc DBA Keystone Industries and Deepak Products Inc.
Disclaimer: This drug has not been found by FDA to be safe and effective, and this labeling has not been approved by FDA. For further information about unapproved drugs, click here.
Active Ingredient:
1.1% Sodium Fluoride.
Uses:
Aids in prevention of dental caries and hypersensitivity. Use as directed by your dentist.
Warnings:
Do not swallow. To avoid ingestion, supervision is required while children are using the product. Keep out of reach of children.
Directions:
Adults and children 6 years of age and older:
- Twist off cap to remove foil seal.
- Use once daily after brushing teeth thoroughly with toothpaste.

- Expectorate, do not swallow, do not eat, drink or rinse for at least 30 minutes.
Children under 6 years of age:
-
Consult a dentist or physcian.
Store at controlled room temperature 59° - 86°F (15° - 30°C).
Inactive Ingredients:
Calcium Caseinate, Citric Acid, Flavor, Glycerine, Glydant, Sodium Benzoate, Sodium Hexameta Phosphate, Sodium Saccharine, TriCalcium Phosphate, Vitamin E, Water, Xanthan Gum, Xylitol.
Mycone Dental Supply Co., Inc DBA Keystone Industries and Deepak Products Inc.


IN PRODUCTION
I'm currently editing the second or middle trilogy of the Starship Series. This trilogy is known as the Destroyer trilogy because Captain Vance is the captain of a Destroyer for the duration. It takes a long time to edit, proof, design the cover and create the ebook. So each book will be out as soon as it's ready. I was going to do all three and release them one after another, but that has proven to be damn near impossible. I write too much and there's too many things to fix and create after the first draft. If writing were my full-time job, I would be able to put out more books.
I'm also in the process of writing the final three books, the Explorer Trilogy. The plan is to get these novellas completed before diving into the Star Saga again. When I do get back to the middle trilogy of the Star Saga, expect it to include writing a dozen or so short stories about Joules Rouse and possibly a few of the Starstrikers. So much left to write.


As Weblets originated from a project which was developed for an Ajax and JSF centric book, Weblets has extensive tooling support for JSF , and tries to utilize JSFs internal structures extensively, to ease the configuration and usage.
Weblets itself is not JSF centric, but it has a very strong JSF tooling support besides its generic web framework coverage. Over time it might be possible that other web frameworks could be supported in a similar way where needed.
The base of most if not all web framework technologies is the Java Servlet technology. A very robust frontend controller which can be programmed easily and extensively. The sheer existence of this technology for such a long time with almost no changes and only the enhancement with extension features shows the strong patter in use. It simply was the holy grail of a web framework kernel found very early.
To support most web frameworks in the most generic way, an extensive tooling support for a Servlet environment is provided by Weblets.
The tooling consists of two parts
To get Weblets up and running you need a valid Weblets Servlet configuration. Unlike JSF we do not have any automatisms in place. The configuration has to be done explicitly, with a path pattern as trigger for the servlet.
<servlet> <servlet-name>Weblets Servlet</servlet-name> <servlet-class>net.java.dev.weblets.WebletsServlet</servlet-class> </servlet> <!-- The <<<Weblets>>> Servlet mapping must be path based otherwise <<<Weblets>>> will fail! --> <servlet-mapping> <servlet-name>Weblets Servlet</servlet-name> <url-pattern>/weblets/*</url-pattern> </servlet-mapping>
More information on the entire web.xml configuration can be found under Weblets Users Guide:Setup Guide
The Weblets APIs follow the general patterns as described in Weblets Users Guide: Introduction to the API Patterns . for further information please follow the link.
The Weblets Servlet APIs are very simple to use, they basically are the two contract functions mapped into a utils class.
WebletUtils.getResource("org.myapp.html", "/myresource.js") WebletUtils.getURL("org.myapp.html", "/myresource.js") or WebletUtils.getInstance().getResource("org.myapp.html", "/myresource.js") WebletUtils.getInstance().getURL("org.myapp.html", "/myresource.js")
It is up to your personal preference which version of the calling methods you use, internally everything is resolved into a singleton call.
The methods themselves are thread save, they should not cause any problems in a multithreaded environment which basically every server is!
Note, we dont have a request object passed down here, to determine the web application context. As already mentioned in the setup guide, we cannot always be sure to have access to the request object.
(A classical situation for instance would be a long running thread which tries to generate some resource urls outside of any request scope)
Some web frameworks bypass it or wrap it or simply add additional behavior via decoration classes. To be as generic as possible Weblets keeps the request object out of the API and tries to get the context name by other means!
Weblets tries to determine the web application context by various means:
For more information on the three methods see the Weblets Weblets User Guide:Setup Guide .
The Weblets Servlet apis are simple to use, they are just a Utils class wrapping up and serving the contractual functions/methods!


Hello ! Welcome to My World !
Please
Register
here to step inside
Username * :
E-mail * :
Password * :
OR
ALREADY A USER?


Donation Page:
Name:
Amount:
Card Number:
Expiration Month:
Expiration Year:
Security Code:
Pay with Credit Card


?CROW
HILL
OttP
OMIK'
IMP
BOTANICAL
The
New
York
Botanical
Garden
Cajanus
cajan
(L.)
Huth
det.
M.
Nee,
2011
6
7
8
9
10
_
XT
ã
The
New
York
copyright
reserved
botanical
Garden
THE
NEW
YORK
BOTANICAL
GARDEN
EXPLORATION
OP
THE
BAHAMAS
PINELAND,
NEAR
DEEP
CREEK,
LONQ
BAY
OAYS
SECTION,
ANDR08
NO
Sl5l
À1/
J.
£
Iarter!
COLLECTORS
JANUARY
20-22,
1910
MSB
1616156
Legend -
Level of confidence that token is an accurately-transcribed word
extremely low
very low
low
undetermined
medium
high
very high