This macro indicates what to do for each level 0 glossary entry. The entry label is given by <label> and the associated number list is given by <number list>. You can redefine \glossentry to use commands like \glossentryname{<label>}, \glossentrydesc{<label>} and \glossentrysymbol{<label>} to display the name, description and symbol fields, or to access other fields, use commands like \glsentryuseri{<label>}. (See §9 Using Glossary Terms Without Links for further details.) You can also use the following commands:
This macro will increment and display the associated counter for the main (level 0) entries if the entrycounter or counterwithin package options have been used. This macro is typically called by \glossentry before \glstarget. The format of the counter is controlled by the macro
Each time you use a glossary entry it creates a hyperlink (if hyperlinks are enabled) to the relevant line in the glossary. Your new glossary style must therefore redefine \glossentry to set the appropriate target. This is done using
where <label> is the entry’s label. Note that you don’t need to worry about whether the hyperref package has been loaded, as \glstarget won’t create a target if \hypertarget hasn’t been defined.
For example, the list style defines \glossentry as follows:
Note also that <number list> will always be of the form
where <number(s)> may contain \delimN (to delimit individual numbers) and/or \delimR (to indicate a range of numbers). There may be multiple occurrences of \setentrycounter[<Hprefix>]{<counter name>}<format cmd>{<number(s)>}, but note that the entire number list is enclosed within the argument of \glossaryentrynumbers. The user can redefine this to change the way the entire number list is formatted, regardless of the glossary style. However the most common use of \glossaryentrynumbers is to provide a means of suppressing the number list altogether. (In fact, the nonumberlist option redefines \glossaryentrynumbers to ignore its argument.) Therefore, when you define a new glossary style, you don’t need to worry about whether the user has specified the nonumberlist package option.
This is used to display sub-entries. The first argument, <level>, indicates the sub-entry level. This must be an integer from 1 (first sub-level) onwards. The remaining arguments are analogous to those for \glossentry described above.
This macro will increment and display the associated counter for the level 1 entries if the subentrycounter package option has been used. This macro is typically called by \subglossentry before \glstarget. The format of the counter is controlled by the macro
Note that \printglossary (which \printglossaries calls) sets
to the current glossary label, so it’s possible to create a glossary style that varies according to the glossary type.
For further details of these commands, see “Displaying the glossary” in the documented code (glossaries-code.pdf).
Example 20 (Creating a completely new style)
If you want a completely new style, you will need to redefine all of the commands and the environment listed above.
For example, suppose you want each entry to start with a bullet point. This means that the glossary should be placed in the itemize environment, so theglossary should start and end that environment. Let’s also suppose that you don’t want anything between the glossary groups (so \glsgroupheading and \glsgroupskip should do nothing) and suppose you don’t want anything to appear immediately after \begin{theglossary} (so \glossaryheader should do nothing). In addition, let’s suppose the symbol should appear in brackets after the name, followed by the description and last of all the number list should appear within square brackets at the end. Then you can create this new glossary style, called, say, mylist, as follows:
Note that this style creates a flat glossary, where sub-entries are displayed in exactly the same way as the top level entries. It also hasn’t used \glsentryitem or \glssubentryitem so it won’t be affected by the entrycounter, counterwithin or subentrycounter package options.
Variations:
____________________________
Example 21 (Creating a new glossary style based on an existing style)
If you want to define a new style that is a slightly modified version of an existing style, you can use \setglossarystyle within the second argument of \newglossarystyle followed by whatever alterations you require. For example, suppose you want a style like the list style but you don’t want the extra vertical space created by \indexspace between groups, then you can create a new glossary style called, say, mylist as follows:
(In this case, you can actually achieve the same effect using the list style in combination with the package option nogroupskip.)
____________________________
Example 22 (Example: creating a glossary style that uses the user1, …, user6 keys)
Suppose each entry not only has an associated symbol, but also units (stored in user1) and dimension (stored in user2). Then you can define a glossary style that displays each entry in a longtable as follows:
____________________________
This section describes some utility commands. Additional commands can be found in the documented code (glossaries-code.pdf).
This iterates through <glossary list>, a comma-separated list of glossary labels (as supplied when the glossary was defined). At each iteration <cs> (which must be a control sequence) is set to the glossary label for the current iteration and <body> is performed. If <glossary list> is omitted, the default is to iterate over all glossaries.
This iterates through all entries in the glossary given by <glossary label>. At each iteration <cs> (which must be a control sequence) is set to the entry label for the current iteration and <body> is performed. If <glossary label> is omitted, \glsdefaulttype (usually the main glossary) is used.
This is like \forglsentries but for each glossary in <glossary list> (a comma-separated list of glossary labels). If <glossary list> is omitted, the default is the list of all defined glossaries. At each iteration <cs> is set to the entry label and <body> is performed. (The current glossary label can be obtained using \glsentrytype{<cs>} within <body>.)
This checks if the glossary given by <label> exists. If it does <true part> is performed, otherwise <false part>.
This checks if the glossary entry given by <label> exists. If it does <true part> is performed, otherwise <false part>. (Note that \ifglsentryexists will always be true after the containing glossary has been displayed via \printglossary or \printglossaries even if the entry is explicitly defined later in the document. This is because the entry has to be defined before it can be displayed in the glossary, see §4.8.1 Technical Issues for further details.)
Does <code> if the entry given by <label> exists. If it doesn’t exist, an error is generated. (This command uses \ifglsentryexists.)
Does the reverse of \glsdoifexists. (This command uses \ifglsentryexists.)
As \glsdoifexists but issues a warning rather than an error if the entry doesn’t exist.
See §14 Unsetting and Resetting Entry Flags.
This checks if the glossary entry given by <label> has any sub-entries. If it does, <true part> is performed, otherwise <false part>.
This checks if the glossary entry given by <label> has a parent entry. If it does, <true part> is performed, otherwise <false part>.
This checks if the glossary entry given by <label> has had the symbol field set. If it has, <true part> is performed, otherwise <false part>.
This checks if the glossary entry given by <label> has had the long field set. If it has, <true part> is performed, otherwise <false part>. This should be true for any entry that has been defined via \newacronym. There is no check for the existance of <label>.
This checks if the glossary entry given by <label> has had the short field set. If it has, <true part> is performed, otherwise <false part>. This should be true for any entry that has been defined via \newacronym. There is no check for the existance of <label>.
This checks if the description field is non-empty for the entry given by <label>. If it has, <true part> is performed, otherwise <false part>. Compare with:
This checks if the description field has been set to just \nopostdesc for the entry given by <label>. If it has, <true part> is performed, otherwise <false part>. There is no check for the existance of <label>.
For all other fields you can use:
This checks if the field given by <field> for the entry identified by <label> is empty. If it is, <true part> is performed, otherwise <false part>. If the field supplied is unrecognised <false part> is performed and a warning is issued. Unlike the above commands, such as \ifglshasshort, an error occurs if the entry is undefined.
The glossaries-prefix package provides additional keys that can be used as prefixes. For example, if you want to specify determiners (such as “a”, “an” or “the”). The glossaries-prefix package automatically loads the glossaries package and has the same package options.
The extra keys for \newglossaryentry are as follows:
Example 23 (Defining Determiners)
Here’s the start of my example document:
Note that I’ve simply replaced glossaries from previous sample documents with glossaries-prefix. Now for a sample definition17.1:
Note that I’ve had to explicitly insert a space after the prefix. This allows for the possibility of prefixes that shouldn’t have a space, such as:
Where a space is required at the end of the prefix, you must use a spacing command, such as \space, \␣ (backslash space) or ~ due to the automatic spacing trimming performed in <key>=<value> options.
The prefixes can also be used with acronyms. For example:
____________________________
The glossaries-prefix package provides convenient commands to use these prefixes with commands such as \gls. Note that the prefix is not considered part of the link text, so it’s not included in the hyperlink (where hyperlinks are enabled).
This is prepends the value of the prefix key (or prefixfirst key, on first use) in front of \gls[<options>]{<label>}[<insert>].
If the prefix key (or prefixfirst, on first use) has been set, this displays the value of that key with the first letter converted to upper case followed by \gls[<options>]{<label>}[<insert>]. If that key hasn’t been set, this is equivalent to \Gls[<options>]{<label>}[<insert>].
As \pgls but converts the prefix to upper case and uses \GLS instead of \gls.
This is prepends the value of the prefixplural key (or prefixfirstplural key, on first use) in front of \glspl[<options>]{<label>}[<insert>].
If the prefixplural key (or prefixfirstplural, on first use) has been set, this displays the value of that key with the first letter converted to upper case followed by \glspl[<options>]{<label>}[<insert>]. If that key hasn’t been set, this is equivalent to \Glspl[<options>]{<label>}[<insert>].
As \pglspl but converts the prefix to upper case and uses \GLSpl instead of \glspl.
Continuing from Example 23, now that I’ve defined my entries, I can use them in the text via the above commands:
which produces:
First use: a support vector machine (SVM). Next use: an SVM. Singular: a sample, l’oeil. Plural: the samples, les yeux.
For a complete document, see sample-prefix.tex.
____________________________
This package also provides the following commands:
Does <true part> if the entry identified by <label> has a non-empty value for the prefix key.
This package also provides the following commands:
Does <true part> if the entry identified by <label> has a non-empty value for the prefixplural key.
Does <true part> if the entry identified by <label> has a non-empty value for the prefixfirst key.
Does <true part> if the entry identified by <label> has a non-empty value for the prefixfirstplural key.
Displays the value of the prefix key for the entry given by <label>. (No check is performed to determine if the entry exists.)
Displays the value of the prefixfirst key for the entry given by <label>. (No check is performed to determine if the entry exists.)
Displays the value of the prefixplural key for the entry given by <label>. (No check is performed to determine if the entry exists.)
Displays the value of the prefixfirstplural key for the entry given by <label>. (No check is performed to determine if the entry exists.)
There are also variants that convert the first letter to upper case17.2:
Example 25 (Adding Determiner to Glossary Style)
You can use the above commands to define a new glossary style that uses the determiner. For example, the following style is a slight modification of the list style that inserts the prefix before the name:
____________________________
Limited accessibility support is provided by the accompanying glossaries-accsupp package, but note that this package is experimental and it requires the accsupp package which is also listed as experimental. This package defines additional keys that may be used when defining glossary entries. The keys are as follows:
For example:
Now \gls{tex} will be equivalent to
The sample file sampleaccsupp.tex illustrates the glossaries-accsupp package.
See the documented code (glossaries-code.pdf) for further details. It is recommended that you also read the accsupp documentation.
The glossaries package comes with a minimal file called minimalgls.tex which can be used for testing. This should be located in the samples subdirectory (folder) of the glossaries documentation directory. The location varies according to your operating system and TEX installation. For example, on my Linux partition it can be found in /usr/local/texlive/2013/texmf-dist/doc/latex/glossaries/. Further information on debugging LATEX code is available at http://www.dickimaw-_books.com/latex/minexample/.
Below is a list of some frequently asked questions about the glossaries package. For a complete list, consult the glossaries FAQ. If that doesn’t help, try posting your query to somewhere like the comp.text.tex newsgroup, the LATEX Community Forum or TEX on StackExchange. Bug reports can be submitted via my package bug report form.
A. This error can occur if you have a fragile command in one of your entry definitions. In most cases using \glsnoexpandfields before defining your entry should fix this, but there are still a few fragile commands that will still cause this error even with \glsnoexpandfields. If this is the case put \protect in front of the fragile command.
A. Check you are using an up to date version of the xkeyval package.
A. xindy discards all commands and braces from the sort string. If your sort string (either specified by the sort key or the name key) only consists of commands, this will be treated by xindy as an empty sort string, which produces an error message in newer versions of xindy. For example, the following will cause a problem:
Either use a different sort key for the entry, for example:
or, if all entries are like this, you may prefer to use the sort=use or sort=def package options. See §2.4 Sorting Options for further details of the sort option.
A. The smallcaps package option uses \textsc to typeset the acronyms. This command converts lower case letters to small capitals, while upper case letters remain their usual size. Therefore you need to specify the acronym in lower case letters.
A. PDFLATEX can break hyperlinks across a line, but LATEX can’t. If you can’t use PDFLATEX then disable the first use links using the package option hyperfirst=false.
A. The easiest way to do this is to specify the smaller package option and redefine \acronymfont to use the required typesetting command. For example, suppose you would like the acronyms displayed in a sans-serif font, then you can do:
A. The easiest way to do this is to specify the smaller package option and redefine \firstacronymfont to use the required command. Note that if you don’t want the acronym on subsequent use to use \textsmaller, you will also need to redefine \acronymfont, as above. For example to make the acronym emphasized on first use, but use the surrounding font for subsequent use, you can do:
A. No. Although it is strongly recommended, you don’t have to use makeglossaries. If you prefer a GUI application and have Java installed, you can use makeglossariesgui instead. Otherwise you can just call makeindex explicitly (see §1.3.3 Using makeindex explicitly (Option 2)). Note that you can’t use xindy if you don’t have Perl installed.
A. Read “Upgrading from the glossary package to the glossaries package” which should be available from the same location as this document.
A. The glossaries package currently only supports the following languages: Brazilian Portuguese, Danish, Dutch, English, French, German, Irish, Italian, Hungarian, Polish, Serbian and Spanish. If you want to add another language, send me the translations, and I’ll add them to the next version.
If you are using one of the above languages, but the text hasn’t been translated, try using the glossaries package option translate=babel. Also, try adding the language as a global option to the class file.
A. Remember to do the following:
A. Because you haven’t used any entries in the main glossary via commands such as \gls. If you don’t want to use this glossary, you can suppress its creation via the package option nomain.
A. If it’s for an individual entry, then you can use the entry’s sort key to sort it according to a different term. If it’s for the entire alphabet, then you will need to use xindy (instead of makeindex) and use an appropriate xindy language module. Writing xindy modules or styles is beyond the scope of this manual. Further information about xindy can be found at the Xindy Web Site. There is also a link to the xindy mailing list from that site.
If you want to sort according to order of definition or order of use, use the sort package option described in §2.4 Sorting Options.
A. TeX4HT seems to have a problem with the glossary styles that use \indexspace. I don’t know enough about TeX4HT to find out why. Either use a different glossary style or redefine the style command that uses \indexspace.  This makes it consistent with \makefirstuc. (The textcase package is automatically loaded by glossaries.)
2.3Actually it sets \acronymtype to \glsdefaulttype if the acronym package option is not used, but \glsdefaulttype usually has the value main unless the nomain option has been used.
4.1This is because \acronymtype is set to \glsdefaulttype if the acronym package option is not used.
6.1\glsdisplayfirst and \glsdisplay are now deprecated. Backwards compatibility should be preserved but you may need to use the compatible-3.07 option
8.1makeindex will always assign a location number, even if it’s not needed, so it needs to be discarded.
8.2Ifyou redefine \glsseeformat, keep the default value of the optional argument as \seename as both see and \glssee explicitly write [\seename] in the output file if no optional argument is given.
8.3In versions before 3.0, \glsentryname was used, but this could cause problems when the name key was sanitized.
9.1versions before 3.0 used \glsentryname as the default, but this could cause problems when name had been sanitized.
10.1you can’t use the longheaderborder style for this example as you can’t use the longtable environment in two column mode.
11.1see \setCompositor described in §3 Setting Up
11.2see \setAlphaCompositor described in §3 Setting Up
13.1as from version 1.18
13.2See David Carlisle’sexplanation in http://tex.stackexchange.com/questions/86565/drawbacks-_of-_xspace
15.1These lengths will not be available if you use both the nolong and nosuper package options or if you use the nostyles package option unless you explicitly load the relevant package.
15.2This style was supplied by Axel Menzel.
15.3e.g. with the flowfram package.
17.1Single letter words, such as “a” and “I” should typically not appear at the end of a line, hence the non-breakable space after “a” in the prefix field.
17.2The earlier caveats about initial non-Latin characters apply.


CARRINGTON ANTIFUNGAL- miconazole nitrate cream
SOOTHE AND COOL FREE INZO ANTIFUNGAL- miconazole nitrate cream
REMEDY ANTIFUNGAL WITH OLIVAMINE- miconazole nitrate cream
Medline Industries, Inc.
Disclaimer: Most OTC drugs are not reviewed and approved by FDA, however they may be marketed if they comply with applicable regulations and policies. FDA has not evaluated whether this product complies.
Active ingredient
Miconazole Nitrate 2%
Use
- For the treatment of most athlete’s foot (tinea pedis), jock itch (tinea cruris), ringworm (tinea corporis)
- For the treatment of superficial skin infections caused by yeast (Candida albicans)
- Relieves itching, scaling, cracking, burning, redness, soreness, irritation, discomfort and chafing associated with jock itch.
Warnings
For external use only
Do not use
- on children under 2 years of age unless directed by a doctor
- avoid contact with the eyes
- for athlete's foot and ringworm - if irritation occurs or if there is no improvement within 4 weeks, discontinue use and consult a doctor
- for jock itch - if irritation occurs, or if there is no improvement within 2 weeks, discontinue use and consult a doctor
Keep out of reach of children.
If swallowed, get medical help or contact a Poison Control Center right away.
Directions
- Clean the affected area and dry thoroughly.
- Apply a layer of cream over affected area twice daily (morning and night) or as directed by a doctor.
- Supervise children in the use of this product.
- For athlete’s foot , pay special attention to spaces between the toes: wear well-fitting, ventilated shoes, and change socks at least once daily.
- For athlete’s foot and ringworm, use daily for 4 weeks.
- For jock itch, use daily for 2 weeks.
- If condition persists longer, consult a doctor. This product is not effective on the scalp or nails.
Other information
- Protect from freezing. Avoid excessive heat.
Inactive ingredients
Acrylates/Octylacrylamide Copolymer, Aloe Barbadensis Leaf Juice, Apricot Kernel Oil PEG-6 Esters, Ascorbic Acid, Ascorbyl Palmitate, Cetyl Dimethicone, Cholecalciferol, Citric Acid, Citrus Aurantium Dulcis Peel Oil, Citrus Grandis Peel Oil, Citrus Tangerina Peel Oil, Diazolidinyl Urea, Glycine, Glycine Soja Oil, Glycol Stearate, Hydroxytyrosol, L-proline, L-taurine, Methylparaben, Methylsulfonylmethane, N-acetyl-L-cysteine, Niacinamide, Olea Europaea Fruit Oil, PEG-6 Stearate, PEG-8, PEG-32 Stearate, Polyisobutene, Polysorbate-20, Propanediol, Propylene Glycol, Propylparaben, Pyridoxine HCl, Retinyl Palmiate, Silica, Tocopherol, Triethanolamine, Vanillin, Water, Zea Mays Oil.
Principal Display Panel - Remedy
N 53329-162-04
MEDLINE
REMEDY
WITH OLIVAMINE
ANTIFUNGAL CREAM
TARGETED TREATMENT
Nourishes and helps relieve fungal symptoms of itching, burning and irritation.
NON-ALLERGENIC
NON-SENSITIZING
4 fl oz (118 mL)
Principal Display Panel - Soothe and Cool
NDC 53329-080-58
Soothe&Cool
INZO
Antifungal Cream
(Miconazole Nitrate 2%)
Aids in maintaining healthy skin while treating fungal infections.
REORDER: MSC095632
NET. WT. 2 oz. (56.7g)
Principal Display Panel - Carrington
NDC 53329-079-64
CARRINGTON
ANTIFUNGAL
CREAM
WITH 2%
MICONAZOLE NITRATE
RELIEVES ITCHING
CURES: ATHLETE'S FOOT
RINGWORM
JOCK ITCH
NET WT 5 OZ (141 g)
Medline Industries, Inc.


Here there are the burgers that you have selected
This hamburger contains gluten and lactosa
This hamburger contains lactose
This hamburger contains gluten
This hamburger is gluten and lactose free
Here you put your information
Order confirmation
Name: {{ customer.fullname }}
Street: {{orders.x }} {{ orders.y }}
Email: {{ customer.email }}
House no: {{ customer.house }}
Gender: {{ customer.gender }}
Card: {{ customer.card }}
Ordered burgers:


First Bug Hunting Session for LibreOffice 5.4
LibreOffice 5.4 is due to be announced at the end of July 2017, with many new features (those already implemented are summarized on the release notes page – https://wiki.documentfoundation.org/ReleaseNotes/5.4 – with much more to come).
In order to find, report and triage[…]


Regular primer design using PRIMEGENS.
It integrates Primer3 and BLAST in a pipeline to automate the design of high-quality primers and probes using various efficient algorithms. There are three different algorithms: 1) Sequence-Specific Primer Design (SSPD), 2) Fragment-Specific Primer Design (FSPD), and 3) Probe-Specific Primer Design (PSPD). along with probe design capacity, simply called Probes Design algorithm. For this, it uses query file having the sequence for which primers/probes need to be designed, and the database file having all the sequences that are present in the PCR reaction. Sequences in the database files are used to check for any potential cross-hybridization and thereby select primer/probes that are specific to the query sequence. The user can upload their own customized database file or use available genomes supported by the server. We do not recommend user to upload large database like any genome.


Welcome to bOOTSTRAP
LocalHost @Akash
Class Work :
Welcome
Exercise :
Grid Example
Accordian Example
Carousel Example


WebAssembly Dive In
By Kevin Tan
Background
Compilation
LLVM
Basic API
WASM 1.0 Spec: Design
WASM 1.0 Spec: Instruction
WASM 1.0 Spec: Validation
WASM 1.0 Spec: Memory Model
WASM 1.0 Spec: Binary Format
WebAssembly Post MVC
WebAssembly with Rust


COALESCENCE
INTRODUCTION
Traditional Input devices are unable to keep
up with the advancements of Augmented Reality
UMAMS (Universal Modular Armoured Mobility Solution)
Environmental friendly goals for mobility solutions can be achieved
through several ways
Biped Robots are what laymen would
call Robotic Human Legs. These unique bots are different
Safety and security of personal belongings
such as luggage, purses containing valuables etc.
A Human Arm Robot made by the BITSians at
Sandbox resembles and works like a normal arm.
Imitato Robotics are building Humanoid Robots
which can be controlled by humans wearing an exo-suit.
this project is about
this project is about
this project is about
this project is about


Ole Gunnar Solskjaer names Paul Pogba return date as Man Utd star steps up injury recovery
The French World Cup winner has been out of action since the 1-1 draw against Arsenal at Old Trafford on September 30 but United are hopeful that he will return to first-team training soon
by Matt Maltby, https://www.mirror.co.uk/authors/matt-maltby/Manchester United manager Ole Gunnar Solskjaer says "it won't be too long" before Paul Pogba returns from his ongoing ankle injury.
The French World Cup winner has been out of action for the Red Devils since the 1-1 draw against Arsenal at Old Trafford on September 30.
Since then, United have recorded three wins, two draws and two defeats in the seven games they've played in the star midfielder's abensce.
United are in somewhat of a miserable run of form, having suffered a shock 1-0 defeat at Bournemouth on Saturday, and Solskjaer is hoping to call upon Pogba in the coming weeks.
"He (Pogba) said it himself," the Norwegian head coach told a press conference. "It won’t be too long until he’s out of his cast. He’ll work hard during the international break and hopefully, he’ll be back."
Meanwhile, Solskjaer wants his players to 'fill their boots' in the Europa League against Partizan Belgrade on Thursday.
United are looking to bounce back from another disappointing result in the Premier League with defeat to Bournemouth on Saturday by qualifying for the knockout stages of the Europa League.
Solskjaer's side have taken seven points from their three games so far but have only scored two goals, while they have managed more than one goal in a Premier League game on just two occasions this season.
The Norwegian said: "We'll have to start tomorrow and hope Partizan don't remember this with joy.
"I played in quite a few games at home and if you get a good start you can fill your boots and hopefully we can get off to a good start tomorrow. Front-foot football.
"We've had so many games where we've been 1-0 up and now it's about, come on, let's go for the second and third because maybe we've taken a step back and said we need to get the result for me, and I'd rather these boys just go for and make a mistake or two."


@(item: model.MetaData, curlPaths: Map[String, String] = Map())(implicit request: RequestHeader) @import conf.Switches._ @import conf.Static @import conf.Configuration @* Scripts that should be executed after CSS is loaded *@


- Vector2D - Class in us.ihmc.euclid.tuple2D
-
A 2D vector represents a physical quantity with a magnitude and a direction in the XY-plane.
- Vector2D() - Constructor for class us.ihmc.euclid.tuple2D.Vector2D
-
Creates a new vector and initializes it components to zero.
- Vector2D(double[]) - Constructor for class us.ihmc.euclid.tuple2D.Vector2D
-
Creates a new vector and initializes its component x
, y
in order from the
given array.
- Vector2D(double, double) - Constructor for class us.ihmc.euclid.tuple2D.Vector2D
-
Creates a new vector and initializes it with the given components.
- Vector2D(Tuple2DReadOnly) - Constructor for class us.ihmc.euclid.tuple2D.Vector2D
-
Creates a new vector and initializes it to other
.
- Vector2D(Tuple3DReadOnly) - Constructor for class us.ihmc.euclid.tuple2D.Vector2D
-
Creates a new vector and initializes it to tuple3DReadOnly
x and y components.
- Vector2D32 - Class in us.ihmc.euclid.tuple2D
-
A 2D vector represents a physical quantity with a magnitude and a direction in the XY-plane.
- Vector2D32() - Constructor for class us.ihmc.euclid.tuple2D.Vector2D32
-
Creates a new vector and initializes it components to zero.
- Vector2D32(float[]) - Constructor for class us.ihmc.euclid.tuple2D.Vector2D32
-
Creates a new vector and initializes its component x
, y
in order from the
given array.
- Vector2D32(float, float) - Constructor for class us.ihmc.euclid.tuple2D.Vector2D32
-
Creates a new vector and initializes it with the given components.
- Vector2D32(Tuple2DReadOnly) - Constructor for class us.ihmc.euclid.tuple2D.Vector2D32
-
Creates a new vector and initializes it to other
.
- Vector2DBasics - Interface in us.ihmc.euclid.tuple2D.interfaces
-
Write and read interface for a 2 dimensional vector.
- Vector2DReadOnly - Interface in us.ihmc.euclid.tuple2D.interfaces
-
Read-only interface for a 2 dimensional vector.
- Vector3D - Class in us.ihmc.euclid.tuple3D
-
A 3D vector represents a physical quantity with a magnitude and a direction.
- Vector3D() - Constructor for class us.ihmc.euclid.tuple3D.Vector3D
-
Creates a new vector and initializes it components to zero.
- Vector3D(double[]) - Constructor for class us.ihmc.euclid.tuple3D.Vector3D
-
Creates a new vector and initializes its component x
, y
, z
in order
from the given array.
- Vector3D(double, double, double) - Constructor for class us.ihmc.euclid.tuple3D.Vector3D
-
Creates a new vector and initializes it with the given components.
- Vector3D(Tuple2DReadOnly) - Constructor for class us.ihmc.euclid.tuple3D.Vector3D
-
Creates a new vector and initializes its x and y components to tuple2DReadOnly
.
- Vector3D(Tuple3DReadOnly) - Constructor for class us.ihmc.euclid.tuple3D.Vector3D
-
Creates a new vector and initializes it to other
.
- Vector3D32 - Class in us.ihmc.euclid.tuple3D
-
A 3D vector represents a physical quantity with a magnitude and a direction.
- Vector3D32() - Constructor for class us.ihmc.euclid.tuple3D.Vector3D32
-
Creates a new vector and initializes it components to zero.
- Vector3D32(float[]) - Constructor for class us.ihmc.euclid.tuple3D.Vector3D32
-
Creates a new vector and initializes its component x
, y
, z
in order
from the given array.
- Vector3D32(float, float, float) - Constructor for class us.ihmc.euclid.tuple3D.Vector3D32
-
Creates a new vector and initializes it with the given components.
- Vector3D32(Tuple3DReadOnly) - Constructor for class us.ihmc.euclid.tuple3D.Vector3D32
-
Creates a new vector and initializes it to other
.
- Vector3DBasics - Interface in us.ihmc.euclid.tuple3D.interfaces
-
Write and read interface for a 3 dimensional vector.
- Vector3DReadOnly - Interface in us.ihmc.euclid.tuple3D.interfaces
-
Read-only interface for a 3 dimensional vector.
- Vector4D - Class in us.ihmc.euclid.tuple4D
-
Class used to represent generic quaternions.
- Vector4D() - Constructor for class us.ihmc.euclid.tuple4D.Vector4D
-
Creates a new vector and initializes it components to zero.
- Vector4D(double[]) - Constructor for class us.ihmc.euclid.tuple4D.Vector4D
-
Creates a new vector and initializes its component x
, y
, z
, s
in
order from the given array.
- Vector4D(double, double, double, double) - Constructor for class us.ihmc.euclid.tuple4D.Vector4D
-
Creates a new vector and initializes it with the given components.
- Vector4D(Point3DReadOnly) - Constructor for class us.ihmc.euclid.tuple4D.Vector4D
-
Creates a new vector and initializes it to represent the given 3D point
- Vector4D(Vector3DReadOnly) - Constructor for class us.ihmc.euclid.tuple4D.Vector4D
-
Creates a new vector and initializes it to represent the given 3D vector
- Vector4D(Tuple4DReadOnly) - Constructor for class us.ihmc.euclid.tuple4D.Vector4D
-
Creates a new vector and initializes it to other
.
- Vector4D32 - Class in us.ihmc.euclid.tuple4D
-
Class used to represent generic quaternions.
- Vector4D32() - Constructor for class us.ihmc.euclid.tuple4D.Vector4D32
-
Creates a new vector and initializes it components to zero.
- Vector4D32(float[]) - Constructor for class us.ihmc.euclid.tuple4D.Vector4D32
-
Creates a new vector and initializes its component x
, y
, z
, s
in
order from the given array.
- Vector4D32(float, float, float, float) - Constructor for class us.ihmc.euclid.tuple4D.Vector4D32
-
Creates a new vector and initializes it with the given components.
- Vector4D32(Point3DReadOnly) - Constructor for class us.ihmc.euclid.tuple4D.Vector4D32
-
Creates a new vector and initializes it to represent the given 3D point
- Vector4D32(Vector3DReadOnly) - Constructor for class us.ihmc.euclid.tuple4D.Vector4D32
-
Creates a new vector and initializes it to represent the given 3D vector
- Vector4D32(Tuple4DReadOnly) - Constructor for class us.ihmc.euclid.tuple4D.Vector4D32
-
Creates a new vector and initializes it to other
- Vector4DBasics - Interface in us.ihmc.euclid.tuple4D.interfaces
-
Write and read interface for a 4 dimensional vector representing a generic quaternion.
- Vector4DReadOnly - Interface in us.ihmc.euclid.tuple4D.interfaces
-
Read-only interface for a 4 dimensional vector representing a generic quaternion.


Combinations
Combinations is an iOS testing utility framework suited for fast boundary testing.
Boundary testing or boundary value analysis, is where test cases are generated using the extremes of the input domain, e.g. maximum, minimum, just inside/outside boundaries, typical values, and error values. It is similar to Equivalence Partitioning but focuses on
corner cases.
The framework does just two simple things:
- Generate a set of combinations from test data input set;
- Generate a run-time unit or UI test for each of the combinations;
Check out the API reference for more information.
Simple example:
We have an input form with four fields: First Name
, Email
, Password
and Gender
.
We also have our testing boundary values defined for each field:
- First Name:
John Smith
,empty string
- Email:
<EMAIL_ADDRESS>,john.smith@
,empty string
- Password:
12345
,~@#123ABC
,empty string
- Gender:
Male
,Female
Combinations gets a set of input test data values and transforms it in run-time tests for each generated combination of values.
So for our example the combinations will be:
- [
John Smith
<EMAIL_ADDRESS>,12345
,Male
] - [
John Smith
<EMAIL_ADDRESS>,12345
,Female
] - [
John Smith
<EMAIL_ADDRESS>,~@#123ABC
,Male
] - [
John Smith
<EMAIL_ADDRESS>,~@#123ABC
,Female
] - etc.
For each of this combinations will be generated a test (XCTestCase
)
A running example of the UI Tests generated by Combinations:
Installation
Carthage
If you are using Carthage, you can always use it to build the library within your workspace by adding the line below to your Cartfile
.
github "alexmx/Combinations"
CocoaPods
If you are using CocoaPods, you can as well use it to integrate the library by adding the following lines to your Podfile
.
platform :ios, '8.0'
use_frameworks!
target 'YourAppTarget' do
pod "Combinations"
end
Manual installation
In order to include the Combinations library into your project, you need to build a dynamic framework from provided source code and include it into your project, or inlcude the entire Combinations library as sub-project by copying it to your project directory or include as Git submodule.
Usage
The library requires just two methods to be overriden: valuesForCombinations
and assertCombination:
import XCTest
import Combinations
class MyTests: CombinationsSpec {
override func setUp() {
super.setUp()
}
// Provide input values for Combinations
override class func valuesForCombinations() -> [[Any]]? {
return [
[1, 2, 3, 4],
["John Smith", "John", ""]
]
}
// This method will be called for each generated combination:
// [1, "John Smith"], [1, "John"], [1, ""], [2, "John Smith"], etc.
override func assertCombination(_ combination: [Any]) {
// Perform required asserts on combination
}
}
License
This project is licensed under the terms of the MIT license. See the LICENSE file.


The Raspberry Pi Keyboard Mimic
Status: ConnectedDisconnected
Begin typing to send keystrokes to your Raspberry Pi
Key Mime Pi is released under the MIT License. Source code is available.


PERLDSC
Section: Perl Programmers Reference Guide (1)Updated: 2009-04-11
Index Return to Main Contents
NAME
perldsc - Perl Data Structures CookbookDESCRIPTION
The single feature most sorely lacking in the Perl programming language prior to its 5.0 release was complex data structures. Even without direct language support, some valiant programmers did manage to emulate them, but it was hard work and not for the faint of heart. You could occasionally get away with the $m{$AoA,$b} notation borrowed from awk in which the keys are actually more like a single concatenated string "$AoA$b", but traversal and sorting were difficult. More desperate programmers even hacked Perl's internal symbol table directly, a strategy that proved hard to develop and maintain---to put it mildly.The 5.0 release of Perl let us have complex data structures. You may now write something like this and all of a sudden, you'd have an array with three dimensions!
for $x (1 .. 10) { for $y (1 .. 10) { for $z (1 .. 10) { $AoA[$x][$y][$z] = $x ** $y + $z; } } }
Alas, however simple this may appear, underneath it's a much more elaborate construct than meets the eye!
How do you print it out? Why can't you say just "print @AoA"? How do you sort it? How can you pass it to a function or get one of these back from a function? Is it an object? Can you save it to disk to read back later? How do you access whole rows or columns of that matrix? Do all the values have to be numeric?
As you see, it's quite easy to become confused. While some small portion of the blame for this can be attributed to the reference-based implementation, it's really more due to a lack of existing documentation with examples designed for the beginner.
This document is meant to be a detailed but understandable treatment of the many different sorts of data structures you might want to develop. It should also serve as a cookbook of examples. That way, when you need to create one of these complex data structures, you can just pinch, pilfer, or purloin a drop-in example from here.
Let's look at each of these possible constructs in detail. There are separate sections on each of the following:
- *
- arrays of arrays
- *
- hashes of arrays
- *
- arrays of hashes
- *
- hashes of hashes
- *
- more elaborate constructs
But for now, let's look at general issues common to all these types of data structures.
REFERENCES
The most important thing to understand about all data structures in Perl---including multidimensional arrays---is that even though they might appear otherwise, Perl @ARRAYs and %HASHes are all internally one-dimensional. They can hold only scalar values (meaning a string, number, or a reference). They cannot directly contain other arrays or hashes, but instead contain references to other arrays or hashes.You can't use a reference to an array or hash in quite the same way that you would a real array or hash. For C or C++ programmers unused to distinguishing between arrays and pointers to the same, this can be confusing. If so, just think of it as the difference between a structure and a pointer to a structure.
You can (and should) read more about references in the perlref(1) man page. Briefly, references are rather like pointers that know what they point to. (Objects are also a kind of reference, but we won't be needing them right away---if ever.) This means that when you have something which looks to you like an access to a two-or-more-dimensional array and/or hash, what's really going on is that the base type is merely a one-dimensional entity that contains references to the next level. It's just that you can use it as though it were a two-dimensional one. This is actually the way almost all C multidimensional arrays work as well.
$array[7][12] # array of arrays $array[7]{string} # array of hashes $hash{string}[7] # hash of arrays $hash{string}{'another string'} # hash of hashes
Now, because the top level contains only references, if you try to print out your array in with a simple print() function, you'll get something that doesn't look very nice, like this:
@AoA = ( [2, 3], [4, 5, 7], [0] ); print $AoA[1][2]; 7 print @AoA; ARRAY(0x83c38)ARRAY(0x8b194)ARRAY(0x8b1d0)
That's because Perl doesn't (ever) implicitly dereference your variables. If you want to get at the thing a reference is referring to, then you have to do this yourself using either prefix typing indicators, like "${$blah}", "@{$blah}", "@{$blah[$i]}", or else postfix pointer arrows, like "$a->[3]", "$h->{fred}", or even "$ob->method()->[3]".
COMMON MISTAKES
The two most common mistakes made in constructing something like an array of arrays is either accidentally counting the number of elements or else taking a reference to the same memory location repeatedly. Here's the case where you just get the count instead of a nested array:
for $i (1..10) { @array = somefunc($i); $AoA[$i] = @array; # WRONG! }
That's just the simple case of assigning an array to a scalar and getting its element count. If that's what you really and truly want, then you might do well to consider being a tad more explicit about it, like this:
for $i (1..10) { @array = somefunc($i); $counts[$i] = scalar @array; }
Here's the case of taking a reference to the same memory location again and again:
for $i (1..10) { @array = somefunc($i); $AoA[$i] = \@array; # WRONG! }
So, what's the big problem with that? It looks right, doesn't it? After all, I just told you that you need an array of references, so by golly, you've made me one!
Unfortunately, while this is true, it's still broken. All the references in @AoA refer to the very same place, and they will therefore all hold whatever was last in @array! It's similar to the problem demonstrated in the following C program:
#include <pwd.h> main() { struct passwd *getpwnam(), *rp, *dp; rp = getpwnam("root"); dp = getpwnam("daemon"); printf("daemon name is %s\nroot name is %s\n", dp->pw_name, rp->pw_name); }
Which will print
daemon name is daemon root name is daemon
The problem is that both "rp" and "dp" are pointers to the same location in memory! In C, you'd have to remember to malloc() yourself some new memory. In Perl, you'll want to use the array constructor "[]" or the hash constructor "{}" instead. Here's the right way to do the preceding broken code fragments:
for $i (1..10) { @array = somefunc($i); $AoA[$i] = [ @array ]; }
The square brackets make a reference to a new array with a copy of what's in @array at the time of the assignment. This is what you want.
Note that this will produce something similar, but it's much harder to read:
for $i (1..10) { @array = 0 .. $i; @{$AoA[$i]} = @array; }
Is it the same? Well, maybe so---and maybe not. The subtle difference is that when you assign something in square brackets, you know for sure it's always a brand new reference with a new copy of the data. Something else could be going on in this new case with the "@{$AoA[$i]}" dereference on the left-hand-side of the assignment. It all depends on whether $AoA[$i] had been undefined to start with, or whether it already contained a reference. If you had already populated @AoA with references, as in
$AoA[3] = \@another_array;
Then the assignment with the indirection on the left-hand-side would use the existing reference that was already there:
@{$AoA[3]} = @array;
Of course, this would have the ``interesting'' effect of clobbering @another_array. (Have you ever noticed how when a programmer says something is ``interesting'', that rather than meaning ``intriguing'', they're disturbingly more apt to mean that it's ``annoying'', ``difficult'', or both? :-)
So just remember always to use the array or hash constructors with "[]" or "{}", and you'll be fine, although it's not always optimally efficient.
Surprisingly, the following dangerous-looking construct will actually work out fine:
for $i (1..10) { my @array = somefunc($i); $AoA[$i] = \@array; }
That's because my() is more of a run-time statement than it is a compile-time declaration per se. This means that the my() variable is remade afresh each time through the loop. So even though it looks as though you stored the same variable reference each time, you actually did not! This is a subtle distinction that can produce more efficient code at the risk of misleading all but the most experienced of programmers. So I usually advise against teaching it to beginners. In fact, except for passing arguments to functions, I seldom like to see the gimme-a-reference operator (backslash) used much at all in code. Instead, I advise beginners that they (and most of the rest of us) should try to use the much more easily understood constructors "[]" and "{}" instead of relying upon lexical (or dynamic) scoping and hidden reference-counting to do the right thing behind the scenes.
In summary:
$AoA[$i] = [ @array ]; # usually best $AoA[$i] = \@array; # perilous; just how my() was that array? @{ $AoA[$i] } = @array; # way too tricky for most programmers
CAVEAT ON PRECEDENCE
Speaking of things like "@{$AoA[$i]}", the following are actually the same thing:
$aref->[2][2] # clear $$aref[2][2] # confusing
That's because Perl's precedence rules on its five prefix dereferencers (which look like someone swearing: "$ @ * % &") make them bind more tightly than the postfix subscripting brackets or braces! This will no doubt come as a great shock to the C or C++ programmer, who is quite accustomed to using *a[i] to mean what's pointed to by the i'th element of "a". That is, they first take the subscript, and only then dereference the thing at that subscript. That's fine in C, but this isn't C.
The seemingly equivalent construct in Perl, $$aref[$i] first does the deref of $aref, making it take $aref as a reference to an array, and then dereference that, and finally tell you the i'th value of the array pointed to by $AoA. If you wanted the C notion, you'd have to write "${$AoA[$i]}" to force the $AoA[$i] to get evaluated first before the leading "$" dereferencer.
WHY YOU SHOULD ALWAYS use strict
If this is starting to sound scarier than it's worth, relax. Perl has some features to help you avoid its most common pitfalls. The best way to avoid getting confused is to start every program like this:
#!/usr/bin/perl -w use strict;
This way, you'll be forced to declare all your variables with my() and also disallow accidental ``symbolic dereferencing''. Therefore if you'd done this:
my $aref = [ [ "fred", "barney", "pebbles", "bambam", "dino", ], [ "homer", "bart", "marge", "maggie", ], [ "george", "jane", "elroy", "judy", ], ]; print $aref[2][2];
The compiler would immediately flag that as an error at compile time, because you were accidentally accessing @aref, an undeclared variable, and it would thereby remind you to write instead:
print $aref->[2][2]
DEBUGGING
Before version 5.002, the standard Perl debugger didn't do a very nice job of printing out complex data structures. With 5.002 or above, the debugger includes several new features, including command line editing as well as the "x" command to dump out complex data structures. For example, given the assignment to $AoA above, here's the debugger output:
DB<1> x $AoA $AoA = ARRAY(0x13b5a0) 0 ARRAY(0x1f0a24) 0 'fred' 1 'barney' 2 'pebbles' 3 'bambam' 4 'dino' 1 ARRAY(0x13b558) 0 'homer' 1 'bart' 2 'marge' 3 'maggie' 2 ARRAY(0x13b540) 0 'george' 1 'jane' 2 'elroy' 3 'judy'
CODE EXAMPLES
Presented with little comment (these will get their own manpages someday) here are short code examples illustrating access of various types of data structures.ARRAYS OF ARRAYS
Declaration of an ARRAY OF ARRAYS
@AoA = ( [ "fred", "barney" ], [ "george", "jane", "elroy" ], [ "homer", "marge", "bart" ], );
Generation of an ARRAY OF ARRAYS
# reading from file while ( <> ) { push @AoA, [ split ]; } # calling a function for $i ( 1 .. 10 ) { $AoA[$i] = [ somefunc($i) ]; } # using temp vars for $i ( 1 .. 10 ) { @tmp = somefunc($i); $AoA[$i] = [ @tmp ]; } # add to an existing row push @{ $AoA[0] }, "wilma", "betty";
Access and Printing of an ARRAY OF ARRAYS
# one element $AoA[0][0] = "Fred"; # another element $AoA[1][1] =~ s/(\w)/\u$1/; # print the whole thing with refs for $aref ( @AoA ) { print "\t [ @$aref ],\n"; } # print the whole thing with indices for $i ( 0 .. $#AoA ) { print "\t [ @{$AoA[$i]} ],\n"; } # print the whole thing one at a time for $i ( 0 .. $#AoA ) { for $j ( 0 .. $#{ $AoA[$i] } ) { print "elt $i $j is $AoA[$i][$j]\n"; } }
HASHES OF ARRAYS
Declaration of a HASH OF ARRAYS
%HoA = ( flintstones => [ "fred", "barney" ], jetsons => [ "george", "jane", "elroy" ], simpsons => [ "homer", "marge", "bart" ], );
Generation of a HASH OF ARRAYS
# reading from file # flintstones: fred barney wilma dino while ( <> ) { next unless s/^(.*?):\s*//; $HoA{$1} = [ split ]; } # reading from file; more temps # flintstones: fred barney wilma dino while ( $line = <> ) { ($who, $rest) = split /:\s*/, $line, 2; @fields = split ' ', $rest; $HoA{$who} = [ @fields ]; } # calling a function that returns a list for $group ( "simpsons", "jetsons", "flintstones" ) { $HoA{$group} = [ get_family($group) ]; } # likewise, but using temps for $group ( "simpsons", "jetsons", "flintstones" ) { @members = get_family($group); $HoA{$group} = [ @members ]; } # append new members to an existing family push @{ $HoA{"flintstones"} }, "wilma", "betty";
Access and Printing of a HASH OF ARRAYS
# one element $HoA{flintstones}[0] = "Fred"; # another element $HoA{simpsons}[1] =~ s/(\w)/\u$1/; # print the whole thing foreach $family ( keys %HoA ) { print "$family: @{ $HoA{$family} }\n" } # print the whole thing with indices foreach $family ( keys %HoA ) { print "family: "; foreach $i ( 0 .. $#{ $HoA{$family} } ) { print " $i = $HoA{$family}[$i]"; } print "\n"; } # print the whole thing sorted by number of members foreach $family ( sort { @{$HoA{$b}} <=> @{$HoA{$a}} } keys %HoA ) { print "$family: @{ $HoA{$family} }\n" } # print the whole thing sorted by number of members and name foreach $family ( sort { @{$HoA{$b}} <=> @{$HoA{$a}} || $a cmp $b } keys %HoA ) { print "$family: ", join(", ", sort @{ $HoA{$family} }), "\n"; }
ARRAYS OF HASHES
Declaration of an ARRAY OF HASHES
@AoH = ( { Lead => "fred", Friend => "barney", }, { Lead => "george", Wife => "jane", Son => "elroy", }, { Lead => "homer", Wife => "marge", Son => "bart", } );
Generation of an ARRAY OF HASHES
# reading from file # format: LEAD=fred FRIEND=barney while ( <> ) { $rec = {}; for $field ( split ) { ($key, $value) = split /=/, $field; $rec->{$key} = $value; } push @AoH, $rec; } # reading from file # format: LEAD=fred FRIEND=barney # no temp while ( <> ) { push @AoH, { split /[\s+=]/ }; } # calling a function that returns a key/value pair list, like # "lead","fred","daughter","pebbles" while ( %fields = getnextpairset() ) { push @AoH, { %fields }; } # likewise, but using no temp vars while (<>) { push @AoH, { parsepairs($_) }; } # add key/value to an element $AoH[0]{pet} = "dino"; $AoH[2]{pet} = "santa's little helper";
Access and Printing of an ARRAY OF HASHES
# one element $AoH[0]{lead} = "fred"; # another element $AoH[1]{lead} =~ s/(\w)/\u$1/; # print the whole thing with refs for $href ( @AoH ) { print "{ "; for $role ( keys %$href ) { print "$role=$href->{$role} "; } print "}\n"; } # print the whole thing with indices for $i ( 0 .. $#AoH ) { print "$i is { "; for $role ( keys %{ $AoH[$i] } ) { print "$role=$AoH[$i]{$role} "; } print "}\n"; } # print the whole thing one at a time for $i ( 0 .. $#AoH ) { for $role ( keys %{ $AoH[$i] } ) { print "elt $i $role is $AoH[$i]{$role}\n"; } }
HASHES OF HASHES
Declaration of a HASH OF HASHES
%HoH = ( flintstones => { lead => "fred", pal => "barney", }, jetsons => { lead => "george", wife => "jane", "his boy" => "elroy", }, simpsons => { lead => "homer", wife => "marge", kid => "bart", }, );
Generation of a HASH OF HASHES
# reading from file # flintstones: lead=fred pal=barney wife=wilma pet=dino while ( <> ) { next unless s/^(.*?):\s*//; $who = $1; for $field ( split ) { ($key, $value) = split /=/, $field; $HoH{$who}{$key} = $value; } # reading from file; more temps while ( <> ) { next unless s/^(.*?):\s*//; $who = $1; $rec = {}; $HoH{$who} = $rec; for $field ( split ) { ($key, $value) = split /=/, $field; $rec->{$key} = $value; } } # calling a function that returns a key,value hash for $group ( "simpsons", "jetsons", "flintstones" ) { $HoH{$group} = { get_family($group) }; } # likewise, but using temps for $group ( "simpsons", "jetsons", "flintstones" ) { %members = get_family($group); $HoH{$group} = { %members }; } # append new members to an existing family %new_folks = ( wife => "wilma", pet => "dino", ); for $what (keys %new_folks) { $HoH{flintstones}{$what} = $new_folks{$what}; }
Access and Printing of a HASH OF HASHES
# one element $HoH{flintstones}{wife} = "wilma"; # another element $HoH{simpsons}{lead} =~ s/(\w)/\u$1/; # print the whole thing foreach $family ( keys %HoH ) { print "$family: { "; for $role ( keys %{ $HoH{$family} } ) { print "$role=$HoH{$family}{$role} "; } print "}\n"; } # print the whole thing somewhat sorted foreach $family ( sort keys %HoH ) { print "$family: { "; for $role ( sort keys %{ $HoH{$family} } ) { print "$role=$HoH{$family}{$role} "; } print "}\n"; } # print the whole thing sorted by number of members foreach $family ( sort { keys %{$HoH{$b}} <=> keys %{$HoH{$a}} } keys %HoH ) { print "$family: { "; for $role ( sort keys %{ $HoH{$family} } ) { print "$role=$HoH{$family}{$role} "; } print "}\n"; } # establish a sort order (rank) for each role $i = 0; for ( qw(lead wife son daughter pal pet) ) { $rank{$_} = ++$i } # now print the whole thing sorted by number of members foreach $family ( sort { keys %{ $HoH{$b} } <=> keys %{ $HoH{$a} } } keys %HoH ) { print "$family: { "; # and print these according to rank order for $role ( sort { $rank{$a} <=> $rank{$b} } keys %{ $HoH{$family} } ) { print "$role=$HoH{$family}{$role} "; } print "}\n"; }
MORE ELABORATE RECORDS
Declaration of MORE ELABORATE RECORDS
Here's a sample showing how to create and use a record whose fields are of many different sorts:
$rec = { TEXT => $string, SEQUENCE => [ @old_values ], LOOKUP => { %some_table }, THATCODE => \&some_function, THISCODE => sub { $_[0] ** $_[1] }, HANDLE => \*STDOUT, }; print $rec->{TEXT}; print $rec->{SEQUENCE}[0]; $last = pop @ { $rec->{SEQUENCE} }; print $rec->{LOOKUP}{"key"}; ($first_k, $first_v) = each %{ $rec->{LOOKUP} }; $answer = $rec->{THATCODE}->($arg); $answer = $rec->{THISCODE}->($arg1, $arg2); # careful of extra block braces on fh ref print { $rec->{HANDLE} } "a string\n"; use FileHandle; $rec->{HANDLE}->autoflush(1); $rec->{HANDLE}->print(" a string\n");
Declaration of a HASH OF COMPLEX RECORDS
%TV = ( flintstones => { series => "flintstones", nights => [ qw(monday thursday friday) ], members => [ { name => "fred", role => "lead", age => 36, }, { name => "wilma", role => "wife", age => 31, }, { name => "pebbles", role => "kid", age => 4, }, ], }, jetsons => { series => "jetsons", nights => [ qw(wednesday saturday) ], members => [ { name => "george", role => "lead", age => 41, }, { name => "jane", role => "wife", age => 39, }, { name => "elroy", role => "kid", age => 9, }, ], }, simpsons => { series => "simpsons", nights => [ qw(monday) ], members => [ { name => "homer", role => "lead", age => 34, }, { name => "marge", role => "wife", age => 37, }, { name => "bart", role => "kid", age => 11, }, ], }, );
Generation of a HASH OF COMPLEX RECORDS
# reading from file # this is most easily done by having the file itself be # in the raw data format as shown above. perl is happy # to parse complex data structures if declared as data, so # sometimes it's easiest to do that # here's a piece by piece build up $rec = {}; $rec->{series} = "flintstones"; $rec->{nights} = [ find_days() ]; @members = (); # assume this file in field=value syntax while (<>) { %fields = split /[\s=]+/; push @members, { %fields }; } $rec->{members} = [ @members ]; # now remember the whole thing $TV{ $rec->{series} } = $rec; ########################################################### # now, you might want to make interesting extra fields that # include pointers back into the same data structure so if # change one piece, it changes everywhere, like for example # if you wanted a {kids} field that was a reference # to an array of the kids' records without having duplicate # records and thus update problems. ########################################################### foreach $family (keys %TV) { $rec = $TV{$family}; # temp pointer @kids = (); for $person ( @{ $rec->{members} } ) { if ($person->{role} =~ /kid|son|daughter/) { push @kids, $person; } } # REMEMBER: $rec and $TV{$family} point to same data!! $rec->{kids} = [ @kids ]; } # you copied the array, but the array itself contains pointers # to uncopied objects. this means that if you make bart get # older via $TV{simpsons}{kids}[0]{age}++; # then this would also change in print $TV{simpsons}{members}[2]{age}; # because $TV{simpsons}{kids}[0] and $TV{simpsons}{members}[2] # both point to the same underlying anonymous hash table # print the whole thing foreach $family ( keys %TV ) { print "the $family"; print " is on during @{ $TV{$family}{nights} }\n"; print "its members are:\n"; for $who ( @{ $TV{$family}{members} } ) { print " $who->{name} ($who->{role}), age $who->{age}\n"; } print "it turns out that $TV{$family}{lead} has "; print scalar ( @{ $TV{$family}{kids} } ), " kids named "; print join (", ", map { $_->{name} } @{ $TV{$family}{kids} } ); print "\n"; }
Database Ties
You cannot easily tie a multilevel data structure (such as a hash of hashes) to a dbm file. The first problem is that all but GDBM and Berkeley DB have size limitations, but beyond that, you also have problems with how references are to be represented on disk. One experimental module that does partially attempt to address this need is the MLDBM module. Check your nearest CPAN site as described in perlmodlib for source code to MLDBM.SEE ALSO
perlref(1), perllol(1), perldata(1), perlobj(1)AUTHOR
Tom Christiansen<EMAIL_ADDRESS>update: Wed Oct 23 04:57:50 MET DST 1996
Index
- NAME
- DESCRIPTION
- REFERENCES
- COMMON MISTAKES
- CAVEAT ON PRECEDENCE
- WHY YOU SHOULD ALWAYS use strict
- DEBUGGING
- CODE EXAMPLES
- ARRAYS OF ARRAYS
- HASHES OF ARRAYS
- ARRAYS OF HASHES
- HASHES OF HASHES
- MORE ELABORATE RECORDS
- Database Ties
- SEE ALSO
- AUTHOR
This document was created by man2html, using the manual pages.
Time: 05:29:08 GMT, December 24, 2015


public class Entity.View
extends java.lang.Object
| Constructor and Description |
|---|
Entity.View() |
| Modifier and Type | Method and Description |
|---|---|
void |
add(Entity e)
Add an Entity to this Entities view.
|
boolean |
contains(Entity e)
Check if the View contains a specific Entity
|
Entity[] |
entities(boolean includingMe) |
Player[] |
players(boolean includingMe) |
void |
remove(Entity e)
Remove an Entity from this Entities view.
|
int |
size() |
void |
update()
Update an entities view, remove entities that were in the
previous view, but not in the current, and spawn entities
that only appear in the current view.
|
public boolean contains(Entity e)
e
- public int size()
public void add(Entity e)
e
- public void remove(Entity e)
e
- public void update()
public Entity[] entities(boolean includingMe)
includingMe
- public Player[] players(boolean includingMe)
includingMe
-


This is a diff of the imnci json files in the "expected" and "output" folders.
Visual Diff |
JSON Diff |
|---|---|
|
|
( KB) |


Checkbox
Normal
Normal
Checked, Disabled
Disabled
The First Checkbox is ...
Favorite
Favorite Checked
Favorite Checked, Disabled
Favorite, Disabled
The First Favorite is ...


You can check out the code for this site and other projects I have in the works on my Github. Feel free to also explore the designs below.
This responsive web page was created to help users navigate parts of the Personify a2z Events product. (Content has been redacted.)
This mock-up design is for a company that seeks to become a house of resources for local breweries, wineries, and distilleries.
This landing page mock-up advertises a unique, new company.
Below is a catalog of my graphic design print projects that were created at AlphaGraphics Loudoun.
717.357.4414
<EMAIL_ADDRESS>Erin Bennett 2020. All rights reserved.


A message displays information that explains nearby content
A basic message
A message does not need to have a dismiss button
A message with an icon
Manually dismissing a message is shown below:


A grand jury has ruled that Darren Wilson, a white police officer, accused of shooting dead an unarmed black teenager in August will not be charged.
St. Louis County Prosecuting Attorney Bob McCulloch announced the decision on Monday evening. A grand jury of nine white and three black members had been meeting weekly since August 20 to consider evidence.
McCulloch stressed that the grand jurors were "the only people who heard every witness ... and every piece of evidence".
He said many witnesses presented conflicting statements that ultimately were inconsistent with the physical evidence.
In a statement released shortly after the decision the Brown family said: "We are profoundly disappointed that the killer of our child will not face the consequence of his actions."
"While we understand that many others share our pain, we ask that you channel your frustration in ways that will make a positive change. We need to work together to fix the system that allowed this to happen," the statement added.
"We respectfully ask that you please keep your protests peaceful. Answering violence with violence is not the appropriate reaction. Let's not just make noise, let's make a difference," it said.
React peacefully
President Barack Obama urged people of Ferguson to react peacefully to grand jury decision and asked police to show restraint.
"We are a nation built on the rule of law, so we need to accept that this decision was the grand jury's to make," he said.
Brown's mother, Lesley McSpadden, who was sitting atop a car, burst into tears and began screaming before being whisked away by supporters.
The crowd erupted in anger, converging on the barricade where police in riot gear were standing. They pushed down the barricade and began pelting police with items, including a bullhorn. Police stood their ground.
The Justice Department is also conducting an investigation into possible civil rights violations that could result in federal charges.
The fatal shooting of Brown sparked angry protests in the St. Louis suburb of Ferguson.
Missouri Governor Jay Nixon traveled to St Louis and held a news conference ahead of the announcement, asking for "peace, respect and restraint".
Authorities quickly stepped up security around the courthouse where the decision was announced. Some nearby businesses boarded up their windows, just as many shops have already done near the site of Brown's death in Ferguson.


Unit 03 - High/Low Guessing Game
Items Accomplished Using Javascript
- Generate Random Numbers
- Round aforementioned numbers using the 'Math' Javascript class.
- Develop code that responds to user input/clicks
- Use switch statements to utilize logic based upon various conditions
- Use if/else statements to create complex functions
- Create elements in the DOM
- Set CSS attributes for these elements
- Add content to the end of the children of other DOM elements
Please guess the secret number between 0 and 16!
You'll receive a ribbon base on how quickly you guess the secret number.


Home
Sales
Sales
Add a new city
City name:
Minimum customers:
Maximum customers:
Average of sales:
Save city information


--- layout: post title: ! '''Ruby on Rails is unbelievably good''' categories: - praise author: admin published: true date: 2005-01-25 14:52:19.000000000 +00:00 ---
Daryl discovers Ruby on Rails:
Ruby on Rails is unbelievably good. It’s too good to be true almost… Quite honestly, in an afternoon I built a completely working web application without the fancy css frills and such mind you, but completely usable that would have taken me the weekend with other methods… I’m still kind of in shock as to how productive I was this weekend with RoR. And this was while learning how to program in Ruby.
Welcome to the new world, Daryl!


1. Upload a CSV file below. Make sure it has the following columns: companyName, website, concept, metWith, riskOpp, keyFigures, briefSummary, mainTakeaways, potentialConnections
2. You may edit fields, reorder rows, deselect rows, and deselect fields. If a field is red, it means it's gone over the character limit and may not look good in your final presentation.
3. Give your presentation a file name, a title, and a subtitle. When you're ready, click the button to download your powerpoint presentation.