public class FilterIndexReader extends IndexReader
FilterIndexReader
contains another IndexReader, which it
uses as its basic source of data, possibly transforming the data along the
way or providing additional functionality. The class
FilterIndexReader
itself simply implements all abstract methods
of
IndexReader
with versions that pass all requests to the
contained index reader. Subclasses of
FilterIndexReader
may
further override some of these methods and may also provide additional
methods and fields.
Note:
The default implementation of
IndexReader.doOpenIfChanged()
throws
UnsupportedOperationException
(like the base class),
so it's not possible to reopen a
FilterIndexReader
.
To reopen, you have to first reopen the underlying reader
and wrap it again with the custom filter.
| Modifier and Type | Class and Description |
|---|---|
static class
|
FilterIndexReader.FilterTermDocs
Base class for filtering
TermDocs
implementations.
|
static class
|
FilterIndexReader.FilterTermEnum
Base class for filtering
TermEnum
implementations.
|
static class
|
FilterIndexReader.FilterTermPositions
Base class for filtering
TermPositions
implementations.
|
IndexReader.ReaderClosedListener
| Modifier and Type | Field and Description |
|---|---|
protected
IndexReader
|
in
|
hasChanges
| Constructor and Description |
|---|
FilterIndexReader
(
IndexReader
in)
Construct a FilterIndexReader based on the specified base reader.
|
| Modifier and Type | Method and Description |
|---|---|
Directory
|
directory
()
Returns the directory associated with this index.
|
int
|
docFreq
(
Term
t)
Returns the number of documents containing the term
t
.
|
protected void
|
doClose
()
Implements close.
|
protected void
|
doCommit
(
Map
<
String
,
String
> commitUserData)
Deprecated.
|
Document
|
document
(int n,
FieldSelector
fieldSelector)
Get the
Document
at the
n
th
position.
|
protected void
|
doDelete
(int n)
Deprecated.
|
protected void
|
doSetNorm
(int d,
String
f,
byte b)
Deprecated.
|
protected void
|
doUndeleteAll
()
Deprecated.
|
Map
<
String
,
String
>
|
getCommitUserData
()
Retrieve the String userData optionally passed to
IndexWriter#commit.
|
Object
|
getCoreCacheKey
()
If the subclass of FilteredIndexReader modifies the
contents of the FieldCache, you must override this
method to provide a different key
|
Object
|
getDeletesCacheKey
()
If the subclass of FilteredIndexReader modifies the
deleted docs, you must override this method to provide
a different key
|
FieldInfos
|
getFieldInfos
()
Get the
FieldInfos
describing all fields in
this reader.
|
IndexCommit
|
getIndexCommit
()
Expert: return the IndexCommit that this reader has
opened.
|
IndexReader
[]
|
getSequentialSubReaders
()
Expert: returns the sequential sub readers that this
reader is logically composed of.
|
TermFreqVector
|
getTermFreqVector
(int docNumber,
String
field)
Return a term frequency vector for the specified document and field.
|
void
|
getTermFreqVector
(int docNumber,
String
field,
TermVectorMapper
mapper)
Load the Term Vector into a user-defined data structure instead of relying on the parallel arrays of
the
TermFreqVector
.
|
void
|
getTermFreqVector
(int docNumber,
TermVectorMapper
mapper)
Map all the term vectors for all fields in a Document
|
TermFreqVector
[]
|
getTermFreqVectors
(int docNumber)
Return an array of term frequency vectors for the specified document.
|
int
|
getTermInfosIndexDivisor
()
For IndexReader implementations that use
TermInfosReader to read terms, this returns the
current indexDivisor as specified when the reader was
opened.
|
long
|
getUniqueTermCount
()
Returns the number of unique terms (across all fields)
in this reader.
|
long
|
getVersion
()
Version number when this IndexReader was opened.
|
boolean
|
hasDeletions
()
Returns true if any documents have been deleted
|
boolean
|
hasNorms
(
String
field)
Returns true if there are norms stored for this field.
|
boolean
|
isCurrent
()
Check whether any new changes have occurred to the
index since this reader was opened.
|
boolean
|
isDeleted
(int n)
Returns true if document
n
has been deleted
|
boolean
|
isOptimized
()
Deprecated.
|
int
|
maxDoc
()
Returns one greater than the largest possible document number.
|
byte[]
|
norms
(
String
f)
Returns the byte-encoded normalization factor for the named field of
every document.
|
void
|
norms
(
String
f,
byte[] bytes,
int offset)
Reads the byte-encoded normalization factor for the named field of every
document.
|
int
|
numDocs
()
Returns the number of documents in this index.
|
TermDocs
|
termDocs
()
Returns an unpositioned
TermDocs
enumerator.
|
TermDocs
|
termDocs
(
Term
term)
Returns an enumeration of all the documents which contain
term
.
|
TermPositions
|
termPositions
()
Returns an unpositioned
TermPositions
enumerator.
|
TermEnum
|
terms
()
Returns an enumeration of all the terms in the index.
|
TermEnum
|
terms
(
Term
t)
Returns an enumeration of all terms starting at a given term.
|
String
|
toString
()
|
acquireWriteLock
,
addReaderClosedListener
,
clone
,
clone
,
close
,
commit
,
commit
,
decRef
,
deleteDocument
,
deleteDocuments
,
document
,
doOpenIfChanged
,
doOpenIfChanged
,
doOpenIfChanged
,
doOpenIfChanged
,
ensureOpen
,
flush
,
flush
,
getCommitUserData
,
getCurrentVersion
,
getRefCount
,
incRef
,
indexExists
,
lastModified
,
listCommits
,
numDeletedDocs
,
open
,
open
,
open
,
open
,
open
,
open
,
open
,
open
,
open
,
open
,
open
,
openIfChanged
,
openIfChanged
,
openIfChanged
,
openIfChanged
,
removeReaderClosedListener
,
reopen
,
reopen
,
reopen
,
reopen
,
setNorm
,
setNorm
,
termPositions
,
tryIncRef
,
undeleteAll
protected IndexReader in
public FilterIndexReader( IndexReader in)
Construct a FilterIndexReader based on the specified base reader. Directory locking for delete, undeleteAll, and setNorm operations is left to the base reader.
Note that base reader is closed if this FilterIndexReader is closed.
in
- specified base reader.
public Directory directory()
IndexReader
directory
in class
IndexReader
public IndexCommit getIndexCommit() throws IOException
IndexReader
getIndexCommit
in class
IndexReader
IOException
public FieldInfos getFieldInfos()
IndexReader
FieldInfos
describing all fields in
this reader. NOTE: do not make any changes to the
returned FieldInfos!
getFieldInfos
in class
IndexReader
public int getTermInfosIndexDivisor()
IndexReader
getTermInfosIndexDivisor
in class
IndexReader
public TermFreqVector [] getTermFreqVectors(int docNumber) throws IOException
IndexReader
TermFreqVector
or of type
TermPositionVector
if
positions or offsets have been stored.
getTermFreqVectors
in class
IndexReader
docNumber
- document for which term frequency vectors are returned
IOException
- if index cannot be accessed
Field.TermVector
public TermFreqVector getTermFreqVector(int docNumber, String field) throws IOException
IndexReader
TermPositionVector
is returned.
getTermFreqVector
in class
IndexReader
docNumber
- document for which the term frequency vector is returned
field
- field for which the term frequency vector is returned.
IOException
- if index cannot be accessed
Field.TermVector
public void getTermFreqVector(int docNumber, String field, TermVectorMapper mapper) throws IOException
IndexReader
TermFreqVector
.
getTermFreqVector
in class
IndexReader
docNumber
- The number of the document to load the vector for
field
- The name of the field to load
mapper
- The
TermVectorMapper
to process the vector. Must not be null
IOException
- if term vectors cannot be accessed or if they do not exist on the field and doc. specified.
public void getTermFreqVector(int docNumber, TermVectorMapper mapper) throws IOException
IndexReader
getTermFreqVector
in class
IndexReader
docNumber
- The number of the document to load the vector for
mapper
- The
TermVectorMapper
to process the vector. Must not be null
IOException
- if term vectors cannot be accessed or if they do not exist on the field and doc. specified.
public long getUniqueTermCount() throws IOException
IndexReader
getUniqueTermCount
in class
IndexReader
IOException
public int numDocs()
IndexReader
numDocs
in class
IndexReader
public int maxDoc()
IndexReader
maxDoc
in class
IndexReader
public Document document(int n, FieldSelector fieldSelector) throws CorruptIndexException , IOException
IndexReader
Document
at the
n
th
position. The
FieldSelector
may be used to determine
what
Field
s to load and how they should
be loaded.
NOTE:
If this Reader (more specifically, the underlying
FieldsReader
) is closed before the lazy
Field
is loaded an exception may be
thrown. If you want the value of a lazy
Field
to be available after closing you
must explicitly load it or fetch the Document again with a new loader.
NOTE:
for performance reasons, this method does not check if the
requested document is deleted, and therefore asking for a deleted document
may yield unspecified results. Usually this is not required, however you
can call
IndexReader.isDeleted(int)
with the requested document ID to verify
the document is not deleted.
document
in class
IndexReader
n
- Get the document at the
n
th
position
fieldSelector
- The
FieldSelector
to use to determine what
Fields should be loaded on the Document. May be null, in which case
all Fields will be loaded.
Document
at the nth position
CorruptIndexException
- if the index is corrupt
IOException
- if there is a low-level IO error
Fieldable
,
FieldSelector
,
SetBasedFieldSelector
,
LoadFirstFieldSelector
public boolean isDeleted(int n)
IndexReader
isDeleted
in class
IndexReader
public boolean hasDeletions()
IndexReader
hasDeletions
in class
IndexReader
@Deprecated protected void doUndeleteAll() throws CorruptIndexException , IOException
doUndeleteAll
in class
IndexReader
CorruptIndexException
IOException
public boolean hasNorms( String field) throws IOException
IndexReader
hasNorms
in class
IndexReader
IOException
public byte[] norms( String f) throws IOException
IndexReader
norms
in class
IndexReader
IOException
AbstractField.setBoost(float)
public void norms( String f, byte[] bytes, int offset) throws IOException
IndexReader
norms
in class
IndexReader
IOException
AbstractField.setBoost(float)
@Deprecated protected void doSetNorm(int d, String f, byte b) throws CorruptIndexException , IOException
doSetNorm
in class
IndexReader
CorruptIndexException
IOException
public TermEnum terms() throws IOException
IndexReader
TermEnum.next()
must be called
on the resulting enumeration before calling other methods such as
TermEnum.term()
.
terms
in class
IndexReader
IOException
- if there is a low-level IO error
public TermEnum terms( Term t) throws IOException
IndexReader
terms
in class
IndexReader
IOException
- if there is a low-level IO error
public int docFreq( Term t) throws IOException
IndexReader
t
.
docFreq
in class
IndexReader
IOException
- if there is a low-level IO error
public TermDocs termDocs() throws IOException
IndexReader
TermDocs
enumerator.
Note: the TermDocs returned is unpositioned. Before using it, ensure
that you first position it with
TermDocs.seek(Term)
or
TermDocs.seek(TermEnum)
.
termDocs
in class
IndexReader
IOException
- if there is a low-level IO error
public TermDocs termDocs( Term term) throws IOException
IndexReader
term
. For each document, the document number, the frequency of
the term in that document is also provided, for use in
search scoring. If term is null, then all non-deleted
docs are returned with freq=1.
Thus, this method implements the mapping:
The enumeration is ordered by document number. Each document number is greater than all that precede it in the enumeration.
termDocs
in class
IndexReader
IOException
- if there is a low-level IO error
public TermPositions termPositions() throws IOException
IndexReader
TermPositions
enumerator.
termPositions
in class
IndexReader
IOException
- if there is a low-level IO error
@Deprecated protected void doDelete(int n) throws CorruptIndexException , IOException
docNum
.
Applications should call
IndexReader.deleteDocument(int)
or
IndexReader.deleteDocuments(Term)
.
doDelete
in class
IndexReader
CorruptIndexException
IOException
@Deprecated protected void doCommit( Map < String , String > commitUserData) throws IOException
doCommit
in class
IndexReader
IOException
protected void doClose() throws IOException
IndexReader
doClose
in class
IndexReader
IOException
public long getVersion()
IndexReader
If this reader is based on a Directory (ie, was
created by calling
IndexReader.open(org.apache.lucene.store.Directory)
, or
IndexReader.openIfChanged(org.apache.lucene.index.IndexReader)
on
a reader based on a Directory), then this method
returns the version recorded in the commit that the
reader opened. This version is advanced every time
IndexWriter.commit()
is called.
getVersion
in class
IndexReader
public boolean isCurrent() throws CorruptIndexException , IOException
IndexReader
If this reader is based on a Directory (ie, was
created by calling
IndexReader.open(org.apache.lucene.store.Directory)
, or
IndexReader.openIfChanged(org.apache.lucene.index.IndexReader)
on
a reader based on a Directory), then this method checks
if any further commits (see
IndexWriter.commit()
have occurred in that directory).
If instead this reader is a near real-time reader
(ie, obtained by a call to
IndexWriter.getReader()
, or by calling
IndexReader.openIfChanged(org.apache.lucene.index.IndexReader)
on a near real-time reader), then this method checks if
either a new commmit has occurred, or any new
uncommitted changes have taken place via the writer.
Note that even if the writer has only performed
merging, this method will still return false.
In any event, if this returns false, you should call
IndexReader.openIfChanged(org.apache.lucene.index.IndexReader)
to get a new reader that sees the
changes.
isCurrent
in class
IndexReader
CorruptIndexException
- if the index is corrupt
IOException
- if there is a low-level IO error
@Deprecated public boolean isOptimized()
isOptimized
in class
IndexReader
public IndexReader [] getSequentialSubReaders()
IndexReader
NOTE: You should not try using sub-readers returned by
this method to make any changes (setNorm, deleteDocument,
etc.). While this might succeed for one composite reader
(like MultiReader), it will most likely lead to index
corruption for other readers (like DirectoryReader obtained
through
IndexReader.open(org.apache.lucene.store.Directory)
. Use the parent reader directly.
getSequentialSubReaders
in class
IndexReader
public Map < String , String > getCommitUserData()
IndexReader
IndexWriter.commit(Map)
has never been called for
this index.
getCommitUserData
in class
IndexReader
public Object getCoreCacheKey()
getCoreCacheKey
in class
IndexReader
public Object getDeletesCacheKey()
getDeletesCacheKey
in class
IndexReader
public String toString()
toString
in class
IndexReader


Detecting municipios with an unusual number of crimes should be the cornerstone of any crime fighting strategy. This charts help monitor crime spikes in each of the more than 2,400 Mexican municipios for selected crimes so that the Mexican government can take prompt action (LOL). Crime spikes are only monitored for the data that was added since the last update (usually the last month), but you can consult historical information from the infographics page. Homicides include feminicides.
Both positive and negative trends are detected and should be obvious from the charts. Some municipalities incorrectly report missing values as zero, or have coding errors. Since it's hard to figure out which values are truly zero or simply missing, and I believe false positives are less costly than false negatives, I didn't adjust for this. This are point-in-time anomalous data points, not the most violent municipalities. Only municipios with more than 10 homicides, 10 car robberies with violence, 10 car robberies without violence and 5 lesions are taken into account.
Author: Diego Valle-Jones
For Mexico City crime information please visit HoyoDeCrimen


This webinar covers the tools available for San Francisco Data Coordinators to complete the dataset inventory.
Excel template for completing the dataset inventory. Note: You must enable macros for the template to work.
Provides data coordinators with detailed guidance on steps 2 and 3 of the data inventory.
Guidebook for City and County of San Francisco data coordinators.
1 page flyer explaining the 3 step data inventory process.
1 page flyer describing the Open Data Program. Use it to explain DataSF to your City colleagues.
Our metadata standard (documentation requirements) for data on DataSF.
Inventory comparing fields from various metadata standards at the local, state and federal level. Used to inform our standard.
Research by our intern on best practices in metadata standards and recommendations for DataSF.
Project charter for creating the City’s metadata standard.
Research and recommendations by our intern on data licensing for DataSF.
Inventory of available licenses we reviewed and licensing policies across cities and states.
Our favorite resource on data licensing by Naomi Korn and Prof Charles Oppenheim. Funded by UK’s JISC under the Discovery Program.
Toolkit for City and County of San Francisco department management and Data Coordinators to release sensitive or protected datasets on the open data portal.
Guide for City and County of San Francisco departments and agencies to implement a process to provide individuals with their own personal data upon request.
1 page flyer explaining the personal data request process.
A variety of departments have expressed interest in starting a Stat program. To help you get started, we created the Stat Starter Kit.
Track our progress against our 3 year plan. Updated quarterly and subject to changes based on need.
Our Year 2 strategic plan covers our 5 core goals and various subgoals and supporting strategies for next 3 years. Updated annually.
Track our progress against our 3 year plan. Updated quarterly and subject to changes based on need.
Our strategic plan covers our 6 core goals and supporting strategies for next 3 years. Updated annually.


'br}
'br}
{\
dh_bash-completion - install bash completions for package
dh_bash-completion [debhelper options]
dh_bash-completion is a debhelper program that is responsible for installing completions for bash, usable installing the *(L"bash-completion*(R" package.
If a file named debian/package.bash-completion exists, then different actions are performed, depending on its format.
It can be a proper completion snippet, and in that case it would be installed in the completion directory, and no other actions would be performed.
It can also be a list of files, with an optionally specified name to call the completion snippet after. The file format is as follows:
my/path/to/foo-completion # this would be installed as "foo-completion" my/path/to/bar-completion baz # this would be installed as "baz"
debhelper|(1)
This program is a part of bash-completion.
David Paleino <d.paleino@gmail.com>


We got interfaces!
- incubate B2C supply-chains
- optimize real-time vortals
- transition compelling models
- generate enterprise e-business
- deliver front-end niches
- empower granular schemas
- enhance user-centric convergence
- expedite front-end vortals
- whiteboard user-centric solutions
- exploit leading-edge bandwidth
- harness wireless content
- mesh plug-and-play networks


University of Western Ontario
The University of Western Ontario, founded in 1878, is ranked 8th in Canada, and 211 worldwide.
It's located in London Ontario, a two hour drive from Toronto. It is home to 3 affiliate universities:
Huron, Brescia and Kings. Western is known for its exceptional academic programs,
breakthrough research discoveries and outstanding student experience. Western has a wide variety of options,
appealing to all types of students with more than 400 undergraduate programs and 88 different graduate degree programs.
Some of the most populat programs at western are Business, Dentistry, Education, and Engineering.
The average Tuition is 7,576.74 CAD and there is an average employment rate of 95.2%.
there are aproxomatly 180 difrent clubs on campus and about 40,000 students.
- Top Programs
- Coffee
- Coffee
- Coffee
- Coffee
- Location
- Brock
- London, Ontario
- Two hour drive from Toronto
- Number of Students:
- 28,386
- Average Tuition:
- Domestic : 7,576 CAD
- International: 24,851. CAD
- Entry Requirements:
- Need low 80s to be considered for most programs
- 6 Grade 12 4U/M courses
- Some programs need supplemental applications
- International rating:
- 205
- Canadian rating:
- 8th
- Average class size:
- 92
Western University
1151 Richmond St
London ON N6A 3K7
Tel:<PHONE_NUMBER>
Admissions:<PHONE_NUMBER>
Fax:<PHONE_NUMBER>
www.westernu.ca


Largest Online Scam Headquarters in Cyberjaya Raided by M’sian Immigration Dept, 1,000 Arrested
by Sheralyn TanTap to listen to this article instead: 🔊 Listen to Post
Last night (20th November), the Malaysian Immigration Department raided a premise in Cyberjaya suspected to be the headquarters of the largest online scam syndicate in Malaysia.
According to Malay Mail, they raided Wisma Mustapha Kamal in Neocyber where almost 1,000 Chinese nationals were arrested.
Photos released on Facebook show rows and rows of computer tables in the premise and dozens of scammers with their hands on their head. A table laid with dozens of handphones were also photographed.
Another photo shows the scammers sitting on the floor in hundreds at what looks like the entrance of the building.
Furthermore, videos taken by locals show several of these scammers jumping out of the window of the building in attempts to escaped getting arrested, while other videos show about 50 scammers running for their life across the road.
Immigration director-general Datuk Khairul Dzaimee Daud is scheduled to hold a press conference on the success of the operation at 12pm today.
Meanwhile, the mini market and Chinese canteen in Neocyber will be closed today.
Full video here:
Also read: Did You Know You Can Now Check If An Online Seller Is A Scammer With This PDRM Portal?


Content
- Introduction
- User guide
- Librarian guide
- Administrators
Introduction
Short guide about different types of users and their abilities
New users can easily
- Register, or
- Use external provider to Log in (Facebook)
Users are able to
- Browse Books and Authors
- Sort by different cases
- Search Books and Authors
- View detailed information about Book or Author
Librarians are responsible and able to
- Create new Book/Author record
- Delete records
- Update existing Book or Author
As the name suggest,
Administrators are able to
- Manage user roles
- Recovery user passwords
- Delete members
- Create users
Administration panel
Administration panel is accessible from navigation bar
Manage user roles
Administration -> Edit (user) -> Edit User Roles


WebSiteName
Home
Page 1
Page 2
Page 3
List
Add
SL
First Name
Email
Job Title
City
Country
Action
{{ index + 1 }}
{{ contact.first_name }} {{ contact.last_name }}
{{ contact.email }}
{{ contact.job_title }}
{{ contact.city }}
{{ contact.country }}
Edit
Delete
Form
×
First Name:
Last Name:
Email:
Job Title:
City:
Country:
Bangladesh
India
USA
Form Edit
×
First Name:
Last Name:
Email:
Job Title:
City:
Country:
Bangladesh
India
USA


Newsletter Error Messages
One of the following error messages will be displayed if a message fails to send.
- "No Messages were sent because there are no recipients for this email." In this case, you must either select one or more roles at the User Role(s) field or enter one or more recipients into the Additional Emails field.
- "No Messages were sent. A confirmation email has been sent to [From Email Address] with a description of the errors that happened during the sending process."
- "An error occurred while sending the email: [Error Description]"


A Product Management Blueprint
I find myself having more conversations with startups – both small and large – about product management. I’ve blogged about some of the tools in my chest here but I haven’t talked much about my “blueprint” for product management, which I find myself laying out in many conversations over coffee. What follows is this process I’ve used a few times over with new teams to get product and engineering moving together, shipping in a predictable manner, and tackling bigger and more strategic projects.
Trust
I need to know how to work with my team, what their working styles are, and how we interact. This starts by simply interacting – specifically, outside of the office. I heard a similar opinion recently from Chris Fry (who ran engineering at Salesforce and Twitter) when he remarked something to the effect of: “you can tell a good PM from a bad one based on if he goes to drinks with his team.” Without getting hung up on whether it’s beers or coffee, it’s more about socialization with your team and time outside the office. My personal approach: expect a dinner invite over to my place when I take on running product for a new team.
Velocity
Once you’ve started to build some rapport, it’s time to get down to business. If being able to quickly commit and ship something isn’t a problem for you, then it’s easy to just assume this is working. In reality most teams I encounter that need PM support don’t have shipping nailed down. You probably already know if you fall into that category of feeling like you can commit and ship vs. not, so if you’re not able to do that a few tips:
- There’s some projects that everyone wants to ship that’s been tried over and over, don’t tackle that first.
- Shipping something is better than nothing. It doesn’t have to be the right thing.
- Sometimes you don’t have to ship something to get velocity, you can launch things you already have
Kill scopeTest things earlier and more iteratively, the more you can validate or try something without requiring a large investment the more everyone feels better about the direction you’re heading.
The key here is to commit to projects, deliver, and move on. Your velocity depends solely on delivery, not tasks, not sprints, not projects, etc. If you haven’t shipped anything in a year, then your velocity for the year is zero. At a later point you should move from the focus on shipping anything to shipping the right things, it’s more important to ship 1 thing that moves the needle than 10 that don’t, but that’s a later concern.
Killing things
On the note of killing scope… I’ve heard it articulated at times, that some engineers are happy when certain PMs show up because it means less work for them. When you go over to an engineer’s desk are you creating more or less work? The answer should be less some large percentage of the time. If you can find a way to accomplish your goals with less effort, it’s always a win. Every project everywhere always needs more time or money, what’s more innovative is how you can help a project to ship without one of those two.
At a broader perspective than just scope – one of the biggest ways product can help engineering is by pushing harder for killing off features and the scope of a product.
If you’ve already shipped things, but they’re not delivering value or not being used, kill them. It’s that simple, it may have been a great idea at the time, but either invest in making sure it’s used or kill it so you don’t have to maintain it.
Roadmap planning
Usually getting velocity and killing things takes 3-6 months to really take full effect. At this point a team feels like they’re not under a pile of technical debt, and they can commit to shipping projects. This is the point when product and engineering are melding and you can really start to have fun about where you’re headed. At this point I’ve seen a huge mix of where engineers are more actively or less actively engaged in this process. And the reality is this is everyone’s job to be thinking about where you’re headed as a company – at least that’s the case for any company that classifies itself as a startup.
My favorite tool for this is a team gridding exercise, you can read more about this here and here. This is often best conducted at an off-site where you have an opportunity for casual conversation which can foster broader thinking beyond the obvious bug fixes or smaller product improvements.
One item of note I’ve heard from teams that have done this or similar exercises is they still have trouble deciding what to do after the fact. The role of product is to get to that decision. The most important part is getting to a decision and not the perfect one, gather data, decide, revisit as you go along. All of this isn’t to say that it’s an arbitrary decision, customers, data all inform that as well as the effort to impact matrix exercise, but in the end a clear direction isn’t executed on consensus.
In conclusion
There’s really no end or done when it comes to the role and the work.
There’s always another milestone and the market is always moving around you. But once you’re able to execute predictably and think in an ordered sense about your roadmap, you’re in a position to be able to monitor and adapt to the market, and even more so experiment and shape the market yourself. At that point you have to keep doing it and then the hard part becomes finding ways of keeping a fresh perspective protip: customers are an important part of that equation
Have tips/tricks/practices that I completely missed here or that you disagree with? I’m always happy to talk with others so drop me a note craig.kerstiens@gmail.com.


Package it.unimi.dsi.fastutil.longs
Provides type-specific classes for long elements or keys.
 -
Class Summary Class Description AbstractLong2BooleanFunction An abstract class providing basic methods for functions implementing a type-specific interface.AbstractLong2BooleanMap An abstract class providing basic methods for maps implementing a type-specific interface.AbstractLong2BooleanMap.BasicEntry This class provides a basic but complete type-specific entry class for all those maps implementations that do not have entries on their own (e.g., most immutable maps).AbstractLong2BooleanMap.BasicEntrySet This class provides a basic implementation for an Entry set which forwards some queries to the map.AbstractLong2BooleanSortedMap An abstract class providing basic methods for sorted maps implementing a type-specific interface.AbstractLong2ByteFunction An abstract class providing basic methods for functions implementing a type-specific interface.AbstractLong2ByteMap An abstract class providing basic methods for maps implementing a type-specific interface.AbstractLong2ByteMap.BasicEntry This class provides a basic but complete type-specific entry class for all those maps implementations that do not have entries on their own (e.g., most immutable maps).AbstractLong2ByteMap.BasicEntrySet This class provides a basic implementation for an Entry set which forwards some queries to the map.AbstractLong2ByteSortedMap An abstract class providing basic methods for sorted maps implementing a type-specific interface.AbstractLong2CharFunction An abstract class providing basic methods for functions implementing a type-specific interface.AbstractLong2CharMap An abstract class providing basic methods for maps implementing a type-specific interface.AbstractLong2CharMap.BasicEntry This class provides a basic but complete type-specific entry class for all those maps implementations that do not have entries on their own (e.g., most immutable maps).AbstractLong2CharMap.BasicEntrySet This class provides a basic implementation for an Entry set which forwards some queries to the map.AbstractLong2CharSortedMap An abstract class providing basic methods for sorted maps implementing a type-specific interface.AbstractLong2DoubleFunction An abstract class providing basic methods for functions implementing a type-specific interface.AbstractLong2DoubleMap An abstract class providing basic methods for maps implementing a type-specific interface.AbstractLong2DoubleMap.BasicEntry This class provides a basic but complete type-specific entry class for all those maps implementations that do not have entries on their own (e.g., most immutable maps).AbstractLong2DoubleMap.BasicEntrySet This class provides a basic implementation for an Entry set which forwards some queries to the map.AbstractLong2DoubleSortedMap An abstract class providing basic methods for sorted maps implementing a type-specific interface.AbstractLong2FloatFunction An abstract class providing basic methods for functions implementing a type-specific interface.AbstractLong2FloatMap An abstract class providing basic methods for maps implementing a type-specific interface.AbstractLong2FloatMap.BasicEntry This class provides a basic but complete type-specific entry class for all those maps implementations that do not have entries on their own (e.g., most immutable maps).AbstractLong2FloatMap.BasicEntrySet This class provides a basic implementation for an Entry set which forwards some queries to the map.AbstractLong2FloatSortedMap An abstract class providing basic methods for sorted maps implementing a type-specific interface.AbstractLong2IntFunction An abstract class providing basic methods for functions implementing a type-specific interface.AbstractLong2IntMap An abstract class providing basic methods for maps implementing a type-specific interface.AbstractLong2IntMap.BasicEntry This class provides a basic but complete type-specific entry class for all those maps implementations that do not have entries on their own (e.g., most immutable maps).AbstractLong2IntMap.BasicEntrySet This class provides a basic implementation for an Entry set which forwards some queries to the map.AbstractLong2IntSortedMap An abstract class providing basic methods for sorted maps implementing a type-specific interface.AbstractLong2LongFunction An abstract class providing basic methods for functions implementing a type-specific interface.AbstractLong2LongMap An abstract class providing basic methods for maps implementing a type-specific interface.AbstractLong2LongMap.BasicEntry This class provides a basic but complete type-specific entry class for all those maps implementations that do not have entries on their own (e.g., most immutable maps).AbstractLong2LongMap.BasicEntrySet This class provides a basic implementation for an Entry set which forwards some queries to the map.AbstractLong2LongSortedMap An abstract class providing basic methods for sorted maps implementing a type-specific interface.AbstractLong2ObjectFunction<V> An abstract class providing basic methods for functions implementing a type-specific interface.AbstractLong2ObjectMap<V> An abstract class providing basic methods for maps implementing a type-specific interface.AbstractLong2ObjectMap.BasicEntry<V> This class provides a basic but complete type-specific entry class for all those maps implementations that do not have entries on their own (e.g., most immutable maps).AbstractLong2ObjectMap.BasicEntrySet<V> This class provides a basic implementation for an Entry set which forwards some queries to the map.AbstractLong2ObjectSortedMap<V> An abstract class providing basic methods for sorted maps implementing a type-specific interface.AbstractLong2ReferenceFunction<V> An abstract class providing basic methods for functions implementing a type-specific interface.AbstractLong2ReferenceMap<V> An abstract class providing basic methods for maps implementing a type-specific interface.AbstractLong2ReferenceMap.BasicEntry<V> This class provides a basic but complete type-specific entry class for all those maps implementations that do not have entries on their own (e.g., most immutable maps).AbstractLong2ReferenceMap.BasicEntrySet<V> This class provides a basic implementation for an Entry set which forwards some queries to the map.AbstractLong2ReferenceSortedMap<V> An abstract class providing basic methods for sorted maps implementing a type-specific interface.AbstractLong2ShortFunction An abstract class providing basic methods for functions implementing a type-specific interface.AbstractLong2ShortMap An abstract class providing basic methods for maps implementing a type-specific interface.AbstractLong2ShortMap.BasicEntry This class provides a basic but complete type-specific entry class for all those maps implementations that do not have entries on their own (e.g., most immutable maps).AbstractLong2ShortMap.BasicEntrySet This class provides a basic implementation for an Entry set which forwards some queries to the map.AbstractLong2ShortSortedMap An abstract class providing basic methods for sorted maps implementing a type-specific interface.AbstractLongBidirectionalIterator Deprecated. As of fastutil 8 this class is no longer necessary, as its previous abstract methods are now default methods of the type-specific interface.AbstractLongBigList An abstract class providing basic methods for big lists implementing a type-specific big list interface.AbstractLongBigList.LongSubList A class implementing a sublist view.AbstractLongBigListIterator Deprecated. As of fastutil 8 this class is no longer necessary, as its previous abstract methods are now default methods of the type-specific interface.AbstractLongCollection An abstract class providing basic methods for collections implementing a type-specific interface.AbstractLongComparator Deprecated. As of fastutil 8 this class is no longer necessary, as its only previous abstract method is now a default method of the type-specific interface.AbstractLongIterator Deprecated. As of fastutil 8 this class is no longer necessary, as its previous abstract methods are now default methods of the type-specific interface.AbstractLongList An abstract class providing basic methods for lists implementing a type-specific list interface.AbstractLongList.LongSubList A class implementing a sublist view.AbstractLongListIterator Deprecated. As of fastutil 8 this class is no longer necessary, as its previous abstract methods are now default methods of the type-specific interface.AbstractLongPriorityQueue Deprecated. As of fastutil 8 this class is no longer necessary, as its previous abstract methods are now default methods of the type-specific interface.AbstractLongSet An abstract class providing basic methods for sets implementing a type-specific interface.AbstractLongSortedSet An abstract class providing basic methods for sorted sets implementing a type-specific interface.AbstractLongStack Deprecated. As of fastutil 8 this class is no longer necessary, as its previous abstract methods are now default methods of the type-specific interface.Long2BooleanArrayMap A simple, brute-force implementation of a map based on two parallel backing arrays.Long2BooleanAVLTreeMap A type-specific AVL tree map with a fast, small-footprint implementation.Long2BooleanFunctions A class providing static methods and objects that do useful things with type-specific functions.Long2BooleanFunctions.EmptyFunction An immutable class representing an empty type-specific function.Long2BooleanFunctions.PrimitiveFunction An adapter for mapping generic total functions to partial primitive functions.Long2BooleanFunctions.Singleton An immutable class representing a type-specific singleton function.Long2BooleanFunctions.SynchronizedFunction A synchronized wrapper class for functions.Long2BooleanFunctions.UnmodifiableFunction An unmodifiable wrapper class for functions.Long2BooleanLinkedOpenHashMap A type-specific linked hash map with with a fast, small-footprint implementation.Long2BooleanMaps A class providing static methods and objects that do useful things with type-specific maps.Long2BooleanMaps.EmptyMap An immutable class representing an empty type-specific map.Long2BooleanMaps.Singleton An immutable class representing a type-specific singleton map.Long2BooleanMaps.SynchronizedMap A synchronized wrapper class for maps.Long2BooleanMaps.UnmodifiableMap An unmodifiable wrapper class for maps.Long2BooleanOpenCustomHashMap A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time.Long2BooleanOpenHashMap A type-specific hash map with a fast, small-footprint implementation.Long2BooleanRBTreeMap A type-specific red-black tree map with a fast, small-footprint implementation.Long2BooleanSortedMaps A class providing static methods and objects that do useful things with type-specific sorted maps.Long2BooleanSortedMaps.EmptySortedMap An immutable class representing an empty type-specific sorted map.Long2BooleanSortedMaps.Singleton An immutable class representing a type-specific singleton sorted map.Long2BooleanSortedMaps.SynchronizedSortedMap A synchronized wrapper class for sorted maps.Long2BooleanSortedMaps.UnmodifiableSortedMap An unmodifiable wrapper class for sorted maps.Long2ByteArrayMap A simple, brute-force implementation of a map based on two parallel backing arrays.Long2ByteAVLTreeMap A type-specific AVL tree map with a fast, small-footprint implementation.Long2ByteFunctions A class providing static methods and objects that do useful things with type-specific functions.Long2ByteFunctions.EmptyFunction An immutable class representing an empty type-specific function.Long2ByteFunctions.PrimitiveFunction An adapter for mapping generic total functions to partial primitive functions.Long2ByteFunctions.Singleton An immutable class representing a type-specific singleton function.Long2ByteFunctions.SynchronizedFunction A synchronized wrapper class for functions.Long2ByteFunctions.UnmodifiableFunction An unmodifiable wrapper class for functions.Long2ByteLinkedOpenHashMap A type-specific linked hash map with with a fast, small-footprint implementation.Long2ByteMaps A class providing static methods and objects that do useful things with type-specific maps.Long2ByteMaps.EmptyMap An immutable class representing an empty type-specific map.Long2ByteMaps.Singleton An immutable class representing a type-specific singleton map.Long2ByteMaps.SynchronizedMap A synchronized wrapper class for maps.Long2ByteMaps.UnmodifiableMap An unmodifiable wrapper class for maps.Long2ByteOpenCustomHashMap A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time.Long2ByteOpenHashMap A type-specific hash map with a fast, small-footprint implementation.Long2ByteRBTreeMap A type-specific red-black tree map with a fast, small-footprint implementation.Long2ByteSortedMaps A class providing static methods and objects that do useful things with type-specific sorted maps.Long2ByteSortedMaps.EmptySortedMap An immutable class representing an empty type-specific sorted map.Long2ByteSortedMaps.Singleton An immutable class representing a type-specific singleton sorted map.Long2ByteSortedMaps.SynchronizedSortedMap A synchronized wrapper class for sorted maps.Long2ByteSortedMaps.UnmodifiableSortedMap An unmodifiable wrapper class for sorted maps.Long2CharArrayMap A simple, brute-force implementation of a map based on two parallel backing arrays.Long2CharAVLTreeMap A type-specific AVL tree map with a fast, small-footprint implementation.Long2CharFunctions A class providing static methods and objects that do useful things with type-specific functions.Long2CharFunctions.EmptyFunction An immutable class representing an empty type-specific function.Long2CharFunctions.PrimitiveFunction An adapter for mapping generic total functions to partial primitive functions.Long2CharFunctions.Singleton An immutable class representing a type-specific singleton function.Long2CharFunctions.SynchronizedFunction A synchronized wrapper class for functions.Long2CharFunctions.UnmodifiableFunction An unmodifiable wrapper class for functions.Long2CharLinkedOpenHashMap A type-specific linked hash map with with a fast, small-footprint implementation.Long2CharMaps A class providing static methods and objects that do useful things with type-specific maps.Long2CharMaps.EmptyMap An immutable class representing an empty type-specific map.Long2CharMaps.Singleton An immutable class representing a type-specific singleton map.Long2CharMaps.SynchronizedMap A synchronized wrapper class for maps.Long2CharMaps.UnmodifiableMap An unmodifiable wrapper class for maps.Long2CharOpenCustomHashMap A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time.Long2CharOpenHashMap A type-specific hash map with a fast, small-footprint implementation.Long2CharRBTreeMap A type-specific red-black tree map with a fast, small-footprint implementation.Long2CharSortedMaps A class providing static methods and objects that do useful things with type-specific sorted maps.Long2CharSortedMaps.EmptySortedMap An immutable class representing an empty type-specific sorted map.Long2CharSortedMaps.Singleton An immutable class representing a type-specific singleton sorted map.Long2CharSortedMaps.SynchronizedSortedMap A synchronized wrapper class for sorted maps.Long2CharSortedMaps.UnmodifiableSortedMap An unmodifiable wrapper class for sorted maps.Long2DoubleArrayMap A simple, brute-force implementation of a map based on two parallel backing arrays.Long2DoubleAVLTreeMap A type-specific AVL tree map with a fast, small-footprint implementation.Long2DoubleFunctions A class providing static methods and objects that do useful things with type-specific functions.Long2DoubleFunctions.EmptyFunction An immutable class representing an empty type-specific function.Long2DoubleFunctions.PrimitiveFunction An adapter for mapping generic total functions to partial primitive functions.Long2DoubleFunctions.Singleton An immutable class representing a type-specific singleton function.Long2DoubleFunctions.SynchronizedFunction A synchronized wrapper class for functions.Long2DoubleFunctions.UnmodifiableFunction An unmodifiable wrapper class for functions.Long2DoubleLinkedOpenHashMap A type-specific linked hash map with with a fast, small-footprint implementation.Long2DoubleMaps A class providing static methods and objects that do useful things with type-specific maps.Long2DoubleMaps.EmptyMap An immutable class representing an empty type-specific map.Long2DoubleMaps.Singleton An immutable class representing a type-specific singleton map.Long2DoubleMaps.SynchronizedMap A synchronized wrapper class for maps.Long2DoubleMaps.UnmodifiableMap An unmodifiable wrapper class for maps.Long2DoubleOpenCustomHashMap A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time.Long2DoubleOpenHashMap A type-specific hash map with a fast, small-footprint implementation.Long2DoubleRBTreeMap A type-specific red-black tree map with a fast, small-footprint implementation.Long2DoubleSortedMaps A class providing static methods and objects that do useful things with type-specific sorted maps.Long2DoubleSortedMaps.EmptySortedMap An immutable class representing an empty type-specific sorted map.Long2DoubleSortedMaps.Singleton An immutable class representing a type-specific singleton sorted map.Long2DoubleSortedMaps.SynchronizedSortedMap A synchronized wrapper class for sorted maps.Long2DoubleSortedMaps.UnmodifiableSortedMap An unmodifiable wrapper class for sorted maps.Long2FloatArrayMap A simple, brute-force implementation of a map based on two parallel backing arrays.Long2FloatAVLTreeMap A type-specific AVL tree map with a fast, small-footprint implementation.Long2FloatFunctions A class providing static methods and objects that do useful things with type-specific functions.Long2FloatFunctions.EmptyFunction An immutable class representing an empty type-specific function.Long2FloatFunctions.PrimitiveFunction An adapter for mapping generic total functions to partial primitive functions.Long2FloatFunctions.Singleton An immutable class representing a type-specific singleton function.Long2FloatFunctions.SynchronizedFunction A synchronized wrapper class for functions.Long2FloatFunctions.UnmodifiableFunction An unmodifiable wrapper class for functions.Long2FloatLinkedOpenHashMap A type-specific linked hash map with with a fast, small-footprint implementation.Long2FloatMaps A class providing static methods and objects that do useful things with type-specific maps.Long2FloatMaps.EmptyMap An immutable class representing an empty type-specific map.Long2FloatMaps.Singleton An immutable class representing a type-specific singleton map.Long2FloatMaps.SynchronizedMap A synchronized wrapper class for maps.Long2FloatMaps.UnmodifiableMap An unmodifiable wrapper class for maps.Long2FloatOpenCustomHashMap A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time.Long2FloatOpenHashMap A type-specific hash map with a fast, small-footprint implementation.Long2FloatRBTreeMap A type-specific red-black tree map with a fast, small-footprint implementation.Long2FloatSortedMaps A class providing static methods and objects that do useful things with type-specific sorted maps.Long2FloatSortedMaps.EmptySortedMap An immutable class representing an empty type-specific sorted map.Long2FloatSortedMaps.Singleton An immutable class representing a type-specific singleton sorted map.Long2FloatSortedMaps.SynchronizedSortedMap A synchronized wrapper class for sorted maps.Long2FloatSortedMaps.UnmodifiableSortedMap An unmodifiable wrapper class for sorted maps.Long2IntArrayMap A simple, brute-force implementation of a map based on two parallel backing arrays.Long2IntAVLTreeMap A type-specific AVL tree map with a fast, small-footprint implementation.Long2IntFunctions A class providing static methods and objects that do useful things with type-specific functions.Long2IntFunctions.EmptyFunction An immutable class representing an empty type-specific function.Long2IntFunctions.PrimitiveFunction An adapter for mapping generic total functions to partial primitive functions.Long2IntFunctions.Singleton An immutable class representing a type-specific singleton function.Long2IntFunctions.SynchronizedFunction A synchronized wrapper class for functions.Long2IntFunctions.UnmodifiableFunction An unmodifiable wrapper class for functions.Long2IntLinkedOpenHashMap A type-specific linked hash map with with a fast, small-footprint implementation.Long2IntMaps A class providing static methods and objects that do useful things with type-specific maps.Long2IntMaps.EmptyMap An immutable class representing an empty type-specific map.Long2IntMaps.Singleton An immutable class representing a type-specific singleton map.Long2IntMaps.SynchronizedMap A synchronized wrapper class for maps.Long2IntMaps.UnmodifiableMap An unmodifiable wrapper class for maps.Long2IntOpenCustomHashMap A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time.Long2IntOpenHashMap A type-specific hash map with a fast, small-footprint implementation.Long2IntRBTreeMap A type-specific red-black tree map with a fast, small-footprint implementation.Long2IntSortedMaps A class providing static methods and objects that do useful things with type-specific sorted maps.Long2IntSortedMaps.EmptySortedMap An immutable class representing an empty type-specific sorted map.Long2IntSortedMaps.Singleton An immutable class representing a type-specific singleton sorted map.Long2IntSortedMaps.SynchronizedSortedMap A synchronized wrapper class for sorted maps.Long2IntSortedMaps.UnmodifiableSortedMap An unmodifiable wrapper class for sorted maps.Long2LongArrayMap A simple, brute-force implementation of a map based on two parallel backing arrays.Long2LongAVLTreeMap A type-specific AVL tree map with a fast, small-footprint implementation.Long2LongFunctions A class providing static methods and objects that do useful things with type-specific functions.Long2LongFunctions.EmptyFunction An immutable class representing an empty type-specific function.Long2LongFunctions.PrimitiveFunction An adapter for mapping generic total functions to partial primitive functions.Long2LongFunctions.Singleton An immutable class representing a type-specific singleton function.Long2LongFunctions.SynchronizedFunction A synchronized wrapper class for functions.Long2LongFunctions.UnmodifiableFunction An unmodifiable wrapper class for functions.Long2LongLinkedOpenHashMap A type-specific linked hash map with with a fast, small-footprint implementation.Long2LongMaps A class providing static methods and objects that do useful things with type-specific maps.Long2LongMaps.EmptyMap An immutable class representing an empty type-specific map.Long2LongMaps.Singleton An immutable class representing a type-specific singleton map.Long2LongMaps.SynchronizedMap A synchronized wrapper class for maps.Long2LongMaps.UnmodifiableMap An unmodifiable wrapper class for maps.Long2LongOpenCustomHashMap A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time.Long2LongOpenHashMap A type-specific hash map with a fast, small-footprint implementation.Long2LongRBTreeMap A type-specific red-black tree map with a fast, small-footprint implementation.Long2LongSortedMaps A class providing static methods and objects that do useful things with type-specific sorted maps.Long2LongSortedMaps.EmptySortedMap An immutable class representing an empty type-specific sorted map.Long2LongSortedMaps.Singleton An immutable class representing a type-specific singleton sorted map.Long2LongSortedMaps.SynchronizedSortedMap A synchronized wrapper class for sorted maps.Long2LongSortedMaps.UnmodifiableSortedMap An unmodifiable wrapper class for sorted maps.Long2ObjectArrayMap<V> A simple, brute-force implementation of a map based on two parallel backing arrays.Long2ObjectAVLTreeMap<V> A type-specific AVL tree map with a fast, small-footprint implementation.Long2ObjectFunctions A class providing static methods and objects that do useful things with type-specific functions.Long2ObjectFunctions.EmptyFunction<V> An immutable class representing an empty type-specific function.Long2ObjectFunctions.PrimitiveFunction<V> An adapter for mapping generic total functions to partial primitive functions.Long2ObjectFunctions.Singleton<V> An immutable class representing a type-specific singleton function.Long2ObjectFunctions.SynchronizedFunction<V> A synchronized wrapper class for functions.Long2ObjectFunctions.UnmodifiableFunction<V> An unmodifiable wrapper class for functions.Long2ObjectLinkedOpenHashMap<V> A type-specific linked hash map with with a fast, small-footprint implementation.Long2ObjectMaps A class providing static methods and objects that do useful things with type-specific maps.Long2ObjectMaps.EmptyMap<V> An immutable class representing an empty type-specific map.Long2ObjectMaps.Singleton<V> An immutable class representing a type-specific singleton map.Long2ObjectMaps.SynchronizedMap<V> A synchronized wrapper class for maps.Long2ObjectMaps.UnmodifiableMap<V> An unmodifiable wrapper class for maps.Long2ObjectOpenCustomHashMap<V> A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time.Long2ObjectOpenHashMap<V> A type-specific hash map with a fast, small-footprint implementation.Long2ObjectRBTreeMap<V> A type-specific red-black tree map with a fast, small-footprint implementation.Long2ObjectSortedMaps A class providing static methods and objects that do useful things with type-specific sorted maps.Long2ObjectSortedMaps.EmptySortedMap<V> An immutable class representing an empty type-specific sorted map.Long2ObjectSortedMaps.Singleton<V> An immutable class representing a type-specific singleton sorted map.Long2ObjectSortedMaps.SynchronizedSortedMap<V> A synchronized wrapper class for sorted maps.Long2ObjectSortedMaps.UnmodifiableSortedMap<V> An unmodifiable wrapper class for sorted maps.Long2ReferenceArrayMap<V> A simple, brute-force implementation of a map based on two parallel backing arrays.Long2ReferenceAVLTreeMap<V> A type-specific AVL tree map with a fast, small-footprint implementation.Long2ReferenceFunctions A class providing static methods and objects that do useful things with type-specific functions.Long2ReferenceFunctions.EmptyFunction<V> An immutable class representing an empty type-specific function.Long2ReferenceFunctions.PrimitiveFunction<V> An adapter for mapping generic total functions to partial primitive functions.Long2ReferenceFunctions.Singleton<V> An immutable class representing a type-specific singleton function.Long2ReferenceFunctions.SynchronizedFunction<V> A synchronized wrapper class for functions.Long2ReferenceFunctions.UnmodifiableFunction<V> An unmodifiable wrapper class for functions.Long2ReferenceLinkedOpenHashMap<V> A type-specific linked hash map with with a fast, small-footprint implementation.Long2ReferenceMaps A class providing static methods and objects that do useful things with type-specific maps.Long2ReferenceMaps.EmptyMap<V> An immutable class representing an empty type-specific map.Long2ReferenceMaps.Singleton<V> An immutable class representing a type-specific singleton map.Long2ReferenceMaps.SynchronizedMap<V> A synchronized wrapper class for maps.Long2ReferenceMaps.UnmodifiableMap<V> An unmodifiable wrapper class for maps.Long2ReferenceOpenCustomHashMap<V> A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time.Long2ReferenceOpenHashMap<V> A type-specific hash map with a fast, small-footprint implementation.Long2ReferenceRBTreeMap<V> A type-specific red-black tree map with a fast, small-footprint implementation.Long2ReferenceSortedMaps A class providing static methods and objects that do useful things with type-specific sorted maps.Long2ReferenceSortedMaps.EmptySortedMap<V> An immutable class representing an empty type-specific sorted map.Long2ReferenceSortedMaps.Singleton<V> An immutable class representing a type-specific singleton sorted map.Long2ReferenceSortedMaps.SynchronizedSortedMap<V> A synchronized wrapper class for sorted maps.Long2ReferenceSortedMaps.UnmodifiableSortedMap<V> An unmodifiable wrapper class for sorted maps.Long2ShortArrayMap A simple, brute-force implementation of a map based on two parallel backing arrays.Long2ShortAVLTreeMap A type-specific AVL tree map with a fast, small-footprint implementation.Long2ShortFunctions A class providing static methods and objects that do useful things with type-specific functions.Long2ShortFunctions.EmptyFunction An immutable class representing an empty type-specific function.Long2ShortFunctions.PrimitiveFunction An adapter for mapping generic total functions to partial primitive functions.Long2ShortFunctions.Singleton An immutable class representing a type-specific singleton function.Long2ShortFunctions.SynchronizedFunction A synchronized wrapper class for functions.Long2ShortFunctions.UnmodifiableFunction An unmodifiable wrapper class for functions.Long2ShortLinkedOpenHashMap A type-specific linked hash map with with a fast, small-footprint implementation.Long2ShortMaps A class providing static methods and objects that do useful things with type-specific maps.Long2ShortMaps.EmptyMap An immutable class representing an empty type-specific map.Long2ShortMaps.Singleton An immutable class representing a type-specific singleton map.Long2ShortMaps.SynchronizedMap A synchronized wrapper class for maps.Long2ShortMaps.UnmodifiableMap An unmodifiable wrapper class for maps.Long2ShortOpenCustomHashMap A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time.Long2ShortOpenHashMap A type-specific hash map with a fast, small-footprint implementation.Long2ShortRBTreeMap A type-specific red-black tree map with a fast, small-footprint implementation.Long2ShortSortedMaps A class providing static methods and objects that do useful things with type-specific sorted maps.Long2ShortSortedMaps.EmptySortedMap An immutable class representing an empty type-specific sorted map.Long2ShortSortedMaps.Singleton An immutable class representing a type-specific singleton sorted map.Long2ShortSortedMaps.SynchronizedSortedMap A synchronized wrapper class for sorted maps.Long2ShortSortedMaps.UnmodifiableSortedMap An unmodifiable wrapper class for sorted maps.LongArrayFIFOQueue A type-specific array-based FIFO queue, supporting also deque operations.LongArrayFrontCodedList Compact storage of lists of arrays using front coding.LongArrayIndirectPriorityQueue A type-specific array-based semi-indirect priority queue.LongArrayList A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing.LongArrayPriorityQueue A type-specific array-based priority queue.LongArrays A class providing static methods and objects that do useful things with type-specific arrays.LongArraySet A simple, brute-force implementation of a set based on a backing array.LongAVLTreeSet A type-specific AVL tree set with a fast, small-footprint implementation.LongBigArrayBigList A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing.LongBigArrays A class providing static methods and objects that do useful things with big arrays.LongBigListIterators A class providing static methods and objects that do useful things with type-specific iterators.LongBigListIterators.BigListIteratorListIterator A class exposing a list iterator as a big-list iterator..LongBigListIterators.EmptyBigListIterator A class returning no elements and a type-specific big list iterator interface.LongBigListIterators.UnmodifiableBigListIterator An unmodifiable wrapper class for big list iterators.LongBigLists A class providing static methods and objects that do useful things with type-specific big lists.LongBigLists.EmptyBigList An immutable class representing an empty type-specific big list.LongBigLists.ListBigList A class exposing a list as a big list.LongBigLists.Singleton An immutable class representing a type-specific singleton big list.LongBigLists.SynchronizedBigList A synchronized wrapper class for big lists.LongBigLists.UnmodifiableBigList An unmodifiable wrapper class for big lists.LongCollections A class providing static methods and objects that do useful things with type-specific collections.LongCollections.EmptyCollection An immutable class representing an empty type-specific collection.LongCollections.IterableCollection A collection wrapper class for iterables.LongCollections.SynchronizedCollection A synchronized wrapper class for collections.LongCollections.UnmodifiableCollection An unmodifiable wrapper class for collections.LongComparators A class providing static methods and objects that do useful things with comparators.LongHeapIndirectPriorityQueue A type-specific heap-based indirect priority queue.LongHeapPriorityQueue A type-specific heap-based priority queue.LongHeaps A class providing static methods and objects that do useful things with heaps.LongHeapSemiIndirectPriorityQueue A type-specific heap-based semi-indirect priority queue.LongIndirectHeaps A class providing static methods and objects that do useful things with indirect heaps.LongIterators A class providing static methods and objects that do useful things with type-specific iterators.LongIterators.EmptyIterator A class returning no elements and a type-specific iterator interface.LongIterators.UnmodifiableBidirectionalIterator An unmodifiable wrapper class for bidirectional iterators.LongIterators.UnmodifiableIterator An unmodifiable wrapper class for iterators.LongIterators.UnmodifiableListIterator An unmodifiable wrapper class for list iterators.LongLinkedOpenCustomHashSet A type-specific linked hash set with with a fast, small-footprint implementation.LongLinkedOpenHashSet A type-specific linked hash set with with a fast, small-footprint implementation.LongLists A class providing static methods and objects that do useful things with type-specific lists.LongLists.EmptyList An immutable class representing an empty type-specific list.LongLists.Singleton An immutable class representing a type-specific singleton list.LongLists.SynchronizedList A synchronized wrapper class for lists.LongLists.SynchronizedRandomAccessList A synchronized wrapper class for random-access lists.LongLists.UnmodifiableList An unmodifiable wrapper class for lists.LongLists.UnmodifiableRandomAccessList An unmodifiable wrapper class for random-access lists.LongOpenCustomHashSet A type-specific hash set with a fast, small-footprint implementation whose hashing strategy is specified at creation time.LongOpenHashBigSet A type-specific hash big set with with a fast, small-footprint implementation.LongOpenHashSet A type-specific hash set with with a fast, small-footprint implementation.LongPriorityQueues A class providing static methods and objects that do useful things with type-specific priority queues.LongPriorityQueues.SynchronizedPriorityQueue A synchronized wrapper class for priority queues.LongRBTreeSet A type-specific red-black tree set with a fast, small-footprint implementation.LongSemiIndirectHeaps A class providing static methods and objects that do useful things with semi-indirect heaps.LongSets A class providing static methods and objects that do useful things with type-specific sets.LongSets.EmptySet An immutable class representing the empty set and implementing a type-specific set interface.LongSets.Singleton An immutable class representing a type-specific singleton set.LongSets.SynchronizedSet A synchronized wrapper class for sets.LongSets.UnmodifiableSet An unmodifiable wrapper class for sets.LongSortedSets A class providing static methods and objects that do useful things with type-specific sorted sets.LongSortedSets.EmptySet An immutable class representing the empty sorted set and implementing a type-specific set interface.LongSortedSets.Singleton A class representing a singleton sorted set.LongSortedSets.SynchronizedSortedSet A synchronized wrapper class for sorted sets.LongSortedSets.UnmodifiableSortedSet An unmodifiable wrapper class for sorted sets.


We got tables!
- visualize 24/7 infrastructures
- embrace world-class communities
- enable next-generation e-services
- enhance best-of-breed supply-chains
- cultivate B2C users
- morph global schemas
- brand clicks-and-mortar infomediaries
- disintermediate wireless web-readiness
- e-enable user-centric e-markets
- utilize collaborative schemas
- productize scalable bandwidth
- recontextualize open-source infrastructures
- visualize ubiquitous schemas
- architect holistic e-markets
- repurpose proactive portals


xdef
and ydef
card in the data
description or .ctl
file (that's why it takes longer to "open"
a preprojected grid data set).
It is very important to point out that the internal
GrADS grid can be any grid as it is completely independent of the preprojected
data grid. Thus, there is nothing stopping you displaying preprojected
data on a very high res lon/lat grid (again, defined in the .ctl
by xdef
and ydef
). In fact, you could create
and open multiple .ctl files with different resolutions and/or regions
which pointed to the same preprojected data file.
When you do a display
(i.e., get a grid of data),
the preprojected data are bilinearly interpolated to the GrADS internal
lat/lon grid. For preprojected scalar fields (e.g., 500 mb heights), the
display is adequate and the precision of the interpolation can be controlled
by xdef
and ydef
to define a higher spatial
resolution grid.
The big virtue of this approach is that all built
in GrADS analytic functions (e.g., aave
, hcurl
...)
continue to work even though the data were not originally on a lon/lat
grid. The downside is that you are not looking directly at your data on
a geographic map. However, one could always define a .ctl file which simply
opened the data file as i,j data and displayed without the map (set
mpdraw
off
). So, in my opinion, this compromise
is not that limiting even if as a modeller you wanted to look at the grid--you
just don't get the map background.
Preprojected vector fields
are
a little trickier, depending on whether the vector is defined relative
to the data grid or relative to the Earth. For example, NMC polar stereo
grids use winds relative to the data grid and thus must be rotated to
the internal GrADS lat/lon grid (again defined in the .ctl
file by the xdef
and ydef
cards).
The only potential problem with working with preprojected
data is defining the projection for GrADS. This is accomplished using
a pdef
card in the data descriptor .ctl
file.
pdef
card is:
pdef isize jsize projtype ipole jpole lonref
gridinc
pdef 53 45 nps 27 49 -105 190.5
where,
ipole
and jpole
are the
(i,j) of the pole referenced from the lower left corner at (1,1) and gridinc
is the dx in km.
A typical NORAPS Lambert-Conformal grid is described below, including the C code which sets up the internal interpolation.
The pdef record for a typical NORAPS Lambert-Conformal grid might
be:
pdef 103 69 lcc 30 -88 51.5 34.5 20 40 -88 90000 90000
where,
103
= #pts in x 69
= #pts in y lcc
= Lambert-Conformal 30
= lat of ref point 88
= lon of ref point (E is positive,
W is negative) 51.5
= i of ref point 34.5
= j of ref point 20
= S true lat 40
= N true lat 88
= standard lon 90000
= dx in M 90000
= dy in M
Wind rotation has also been added so that vector data will be properly displayed.
The pdef card for a typical eta model grid is:
pdef 181 136 eta.u -97.0 41.0 0.38888888 0.37037037
181
= #pts
in x
136
= #pts
in y
eta.u
= eta grid, unstaggered
-97.0
= lon of ref point (E is positive
in GrADS, W is negative) [deg]
41.0
= lat of ref point
[deg]
0.3888
= dlon [deg]
0.37037
= dlat [deg]
Wind rotation has not been implemented!!! Use only for scalar fields.
pdef ni nj pse slat slon polei polej dx dy sgn
ni
= # points in x
nj
=
# points in y
slat
= absolute value of the
standard latitude
slon
= absolute value of the
standard longitude
pse
= polar stereo,
"eccentric"
polei
= x index position of the pole (where
(0,0) is the index of the first point vice the more typical (1,1) )
polej
= y index position of the pole (where
(0,0) is the index of the first point vice the more typical (1,1) )
dx
=
delta x in km
dy
=
delta y in km
sgn
= 1 for N polar
stereo and -1 for S polar stereo
Source code in GrADS for the lon,lat -> i,j mapping:
pdef 26 16 ops 40.0 -100.0 90000.0 90000.0 14.0 9.0 180000.0 180000.0
26
= #pts in x
16
= #pts in y
ops
= oblique polar stereo
40.0
= lat of ref point (14.0, 9.0)
-100.0
= lon of ref point (14.0,
9.0 (E is positive in GrADS, W is negative)
90000.0
= xref offset [m]
90000.0
= yref offset [m]
14.0
= i of ref point
9.0
= j of ref point
180000.0
= dx [m]
180000.0
= dy [m]
u
and v
components must be 33
and 34
(the GRIB
standard) respectively, e.g.,
u 15 33
u component of the wind at 15 pressure
levels v 15 34
v component of the wind at 15 pressure
levels
eta.u
and ops
projection are still
experimental...
i,j
space, transformed to the display device coordinates
(e.g., the screen) and then displayed. That is, the i,j of the graphic element
is converted to lat/lon
and then to x,y
on the screen
via a map projection.
GrADS currently supports four display projections
:
set mproj
nps
);
set mproj
sps
);
As you can probably appreciate, the i,j-to-lon/lat-to-screen x,y for lon/lat
displays is very simple and is considerably more complicated for N and S polar
stereo
projections.
In principle, a Lambert Conformal display projection could be implemented. It just takes work and a simple user interface for setting up that display projection. Actually, the user interface (i.e., "set" calls) is the most difficult problem...