Doing Stuff. Not sure what I'm doing but it's stuff
This has been a dreary day
This is an interesting class
Click to go to Happy Sock's website
I'm hungry
I'm thirsty
I'm sleepy


 The default is true.
at-sign-p—a generalized boolean. The default is implementation-dependent.
tabsize—a non-negative integer. The default is 16.
The functions pprint-fill, pprint-linear, and pprint-tabular specify particular ways of pretty printing a list to stream. Each function prints parentheses around the output if and only if colon-p is true. Each function ignores its at-sign-p argument. (Both arguments are included even though only one is needed so that these functions can be used via ~/.../ and as set-pprint-dispatch functions, as well as directly.) Each function handles abbreviation and the detection of circularity and sharing correctly, and uses write to print object when it is a non-list.
If object is a list and if the value of *print-pretty* is false, each of these functions prints object using a minimum of whitespace, as described in Printing Lists and Conses. Otherwise (if object is a list and if the value of *print-pretty* is true):
The function pprint-linear prints a list either all on one line, or with each element on a separate line.
The function pprint-fill prints a list with as many elements as possible on each line.
The function pprint-tabular is the same as pprint-fill except that it prints the elements so that they line up in columns. The tabsize specifies the column spacing in ems, which is the total spacing from the leading edge of one column to the leading edge of the next.
Evaluating the following with a line length of 25 produces the output shown.
(progn (princ "Roads ") (pprint-tabular *standard-output* '(elm main maple center) nil nil 8)) Roads ELM MAIN MAPLE CENTER
Performs output to the indicated stream.
The cursor position on the indicated stream, if it can be determined.
The function pprint-tabular could be defined as follows:
(defun pprint-tabular (s list &optional (colon-p t) at-sign-p (tabsize nil)) (declare (ignore at-sign-p)) (when (null tabsize) (setq tabsize 16)) (pprint-logical-block (s list :prefix (if colon-p "(" "") :suffix (if colon-p ")" "")) (pprint-exit-if-list-exhausted) (loop (write (pprint-pop) :stream s) (pprint-exit-if-list-exhausted) (write-char #\Space s) (pprint-tab :section-relative 0 tabsize s) (pprint-newline :fill s))))
Note that it would have been inconvenient to specify this function using format, because of the need to pass its tabsize argument through to a ~:T format directive nested within an iteration over a list.
Next: pprint-indent, Previous: pprint-exit-if-list-exhausted, Up: Printer Dictionary


THE BONE COLLECTOR A film review by Mark R. Leeper
Capsule: A surprisingly uninteresting psychotic killer film with a very predictable yet absurd solution. Philip Noyce knows how to give the film a lot of style, but the story is an utter waste of time. People who enjoy seeing blood and pain on the screen will have a good time. For the rest is it a festival of cliches. Rating: 4 (0 to 10), 0 (-4 to +4)
Thomas Harris did a lot that was original with the novel RED DRAGON, later made into the film MANHUNTER. He established or at least revitalized the entire sub-genre of stories of police and psychotic serial killers. This sort of story had been made before but he upped the ante by making the killers more interesting and dangerous. Today the novel would not be as good because so much has been plundered for use elsewhere. Had THE BONE COLLECTOR come out at that time, it would have been a much more intriguing film. But by now most of what it offers is familiar. Phillip Noyce is not new to psychotic killer films. His DEAD CALM is one of the best because it is as much a sea adventure as a murder plot. Now he demonstrates just how important it is to do something creative with the genre by giving us a thriller does just about everything else right and still makes for a very mundane film. THE BONE COLLECTOR gives the ready-made audience who want to see another violent psychotic thriller film a film to see, but does no interesting playing with the genre. The attraction of dealing with a killer who thinks differently than a sane person should be that he is unpredictable. But just about everything about THE BONE COLLECTOR is mechanical and done by the numbers. The killer always leaves a clue to his next crime and the heroes always figure out what the clue means and exactly where the crime will occur down to a street address.
The team of investigators seems to have been pulled from a checklist of ethnic types. We have a beautiful white patrol officer unsure she wants to do forensics. Then there is a black forensic genius confined to a bed and suffering from seizures that he hopes will soon kill him rather than become a vegetable. And finally there is a Latino forensic science researcher.  This gutsy team races the clock and bucks the power structure finding clues that nobody else in the police department can see. This could almost be a TV pilot it is so formulaic.
Lincoln Rhyme (played by Denzel Washington) is the forensic expert who literally wrote the book that defines police detective work. Now he is bed-ridden and subject to seizures that any time may leave him a human vegetable. Before that happens he wants to arrange his own death. Emily Donaghy (Angelina Jolie) is a plucky young patrol officer. When she answers a report about a dead body found she has to stop a train in order to prevent it from rolling over a clue. This brings her censure from her superiors, but earns her the respect of Lincoln Rhyme. Over her own objections she is drafted to help do the detective work to track the killer. The two quickly discover that they are dealing with a psychotic killer who in the best traditions of Batman villains always leaves a puzzle clue to what his next crime will be. The team is rounded out by Eddie Ortez (Luis Guzman), a genius at materials analysis. There is something wrong with the script when with no additional clues the audience gets way ahead of the experts in guessing the killer. About a third of the way through I had a very short list of suspects. But then there were no clues whatsoever until it is revealed who the killer is. When at the end one does know the killer and the motivation it too seems more out of Batman than reality.
Cinematographer Dean Semler does a lot of obvious things to create the feel of the film. Scenes are kept dark and oppressive. When the plot shifts a setting into the sunlight the lens is heavily filtered to give an unwholesome look to the street and sky. Outdoor distance shots try repeatedly and without subtlety to establish that this is Manhattan while close-ups, those that do not take place in the basements and bowels of the city, do not look a lot like New York and in fact are filmed in Montreal.
Denzel Washington plays his role with entirely too much vitality for the man on the brink of death. I am told in the book Rhyme is middle-aged, which would have seemed more believable. Here he happily pokes fun at his own seizures, which seems entirely a wrong gesture for a man in his supposedly depressed state. Angelina Jolie, daughter of Jon Voigt, does little to make the character of Emily Donaghy her own and dozens of young actresses could have been snapped into the same role like interchangeable parts. Luis Guzman, recently of THE LIMEY, is certainly watchable. And Queen Latifah as Rhyme's caregiver matches Washington's amiability.
THE BONE COLLECTOR is an extremely forgettable TV-pilot level serial killer film. Only real fans of the sub-genre will enjoy it. I give it a 4 on the 0 to 10 scale and a 0 on the -4 to +4 scale.
Mark R. Leeper<EMAIL_ADDRESS>Copyright 1999 Mark R. Leeper
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Omics Pipe Available Pipelines
RNA-seq (Tuxedo)
- RNA-seq Tuxedo Modules
- Modules included in the Tuxedo RNA-seq pipeline.
- FASTQC
- TopHat
- Cufflinks
- Cuffmerge
- Cuffmergetocompare
- Cuffdiff
- R Summary Report - CummeRbund
RNA-seq(Anders 2013)
- RNA-seq Count Based Modules
- Modules included in the count-based RNA-seq pipeline.
- FASTQC
- STAR
- HTSEQ
- R Summary Report - DESEQ2
Whole Exome Sequencing (GATK)
- Whole Genome and Whole Exome Sequencing Modules
- Modules included in the whole exome sequencing pipeline.
- FASTQC
- BWA-MEM
- PICARD Mark Duplicates
- GATK Preprocessing
- GATK Variant Discovery
- GATK Variant Filtering
Whole Genome Sequencing (GATK)
- Whole Genome and Whole Exome Sequencing Modules
- Modules included in the whole genome sequencing pipeline.
- FASTQC
- BWA-MEM
- PICARD Mark Duplicates
- GATK Preprocessing
- GATK Variant Discovery
- GATK Variant Filtering
ChIP-seq (MACS)
- ChIP-seq Modules – MACS
- Modules included in the ChIP-seq MACS pipeline.
- FASTQC
- Homer ChIP Trim
- Bowtie
- MACS
ChIP-seq (HOMER)
- ChIP-seq Modules – HOMER
- Modules included in the ChIP-seq HOMER pipeline.
- FASTQC
- Homer ChIP Trim
- Bowtie
- Homer Read Density
- Homer Peaks
- Homer Peak Track
- Homer Annotate Peaks
- Homer Find Motifs
TCGA Reanalysis Pipeline - RNAseq Counts
- RNA-seq Count Based Modules- TCGA
- Modules included in the RNAseq counts pipeline for TCGA reanalysis.
- TCGA Download (GeneTorrent)
- FASTQC
- STAR
- HTSEQ
- Report
miRNAseq Counts (Anders 2013)
- miRNA-seq Count Based Modules
- Modules included in the miRNAseq counts pipeline.
- Cutadapt
- FASTQ Length Filter
- FASTQC
- STAR
- HTSEQ
- Report
miRNAseq (Tuxedo)
- miRNA-seq Tuxedo Modules
- Modules included in the miRNAseq Tuxedo pipeline.
- Cutadapt
- FASTQ Length Filter
- TopHat
- Cufflinks
- Cuffmerge
- Cuffmergetocompare
- Cuffdiff
- R Summary Report


A mailbox export request is a process of exporting mailbox or archive data to a .pst
file. It’s very simple to do with Exchange Management Shell.
The first thing you need to know is that Exchange Management Shell is not the same as Exchange Management Console. As the name suggests, the Shell is a Powershell based command-line interface to manage Exchange.
To export, simply fire up the Exchange Management Shell and use the New-MailboxExportRequest
cmdlet. Lets assume that the user whose mailbox we are exporting is called “John Doe” and his username is “johndoe”
New-MailboxExportRequest -Mailbox johndoe -FilePath "\\server\folder\file.pst"
You can start many export requests at the same time. They will be added to the queue.
Note: You may get an error as follows:
The term "New-MailboxExportRequest" is not recognized.
This may happen because of missing roles. In order to resolve this issue, grant the account performing the export request the ‘Import Export Mailbox’ role assignment.
New-ManagementRoleAssignment –Role “Mailbox Import Export” –User "DOMAIN\USER"
Restart your powershell session and try again.
To see the status while it is exporting, use this cmdlet:
Get-MailboxExportRequest
You can use various formatting options:
Get-MailboxExportRequest | Format-List
Get-MailboxExportRequest | Format-Wide -Property Mailbox
Get-MailboxExportRequest | Format-Table
Get-MailboxExportRequest | Format-Table -Wrap
Get-MailboxExportRequest | Format-Table -Property Mailbox, Status
Completed mailbox export requests aren’t cleared automatically. You can remove fully or partially completed mailbox export requests by using the following cmdlets.
This will remove the export request only for the user “John Doe”.
Remove-MailboxExportRequest -Identity "John Doe\MailboxExport"
This will remove all completed export requests.
Get-MailboxExportRequest -Status Completed | Remove-MailboxExportRequest
To read more about exporting mailboxes, you can check out this TechNet article by Microsoft.
(header image source: wallpaperscastle.com)


1-bit adder with carry input (full adder)
In this exercise, we will create a 1-bit adder with a carry input and a carry output (also named full adder). You will need to create an entity that:
- uses a, b, cin as its input
- outputs its sum to s and carry to cout
You can use the signals carry1, carry2 and s1 below to get your final ouputs.


{% extends 'base.html' %} {% load blog_tags %} {% block title %}
It is a simple blogging website with many extraordinary features
This site contains {% total_posts %} posts so far


Index
All Classes|All Packages
T
- tabTurnNotActive(boolean) - Method in class it.polimi.ingsw.client.gui.controllergui.PlayerViewController
-
Sets the tab with the turn choice.
- takeMaterials(Map<Resource, Integer>) - Method in class it.polimi.ingsw.model.resource.ResourceHandler
-
This method removes a certain quantity of materials, firstly from the additional deposit, then from the deposit and lastly from the strongbox
- test() - Method in class it.polimi.ingsw.client.cli.views.otherviews.AllPlayersView
-
Handles the user input for the selection of the player's gameboard the current player wants to see or the part of the gameboard he wants to see
- testAddReturnMaterials() - Method in class it.polimi.ingsw.model.resource.StrongboxTest
-
This test checks the correct functionality of the addMaterials method and the getQuantity method passing a String that identifies the material needed, then removes an amount of materials and checks the correct functionality of the returnMaterials method and its error handling
- testCheckTakeMaterialsAdditionalDeposit() - Method in class it.polimi.ingsw.model.resource.ResourceHandlerTest
- testCheckTakeMaterialsDeposit() - Method in class it.polimi.ingsw.model.resource.ResourceHandlerTest
- testCheckTakeMaterialsStrongbox() - Method in class it.polimi.ingsw.model.resource.ResourceHandlerTest
- testCheckVaticanReportSection() - Method in class it.polimi.ingsw.model.faithtrack.FaithTrackTest
-
This test checks the right behaviour of the testCheckVaticanReportSection method that check if a player is in a specified vatican report section
- testForwardPos() - Method in class it.polimi.ingsw.model.faithtrack.FaithTrackTest
-
This test checks the right behaviour of the testForwardPos method controlling if the method returns true when a player arrives on a pope space and next disable that space
- TestGameboard() - Method in class it.polimi.ingsw.model.gameboard.GameboardTest
-
This test checks the correct handle of the pope favor tiles inside the gameBoard the other methods are not tested because are only getter method of classes that has been tested in other tests
- testGetEffect() - Method in class it.polimi.ingsw.model.leadercard.LeaderCardTest
- testGetMaterialType() - Method in class it.polimi.ingsw.model.leadercard.LeaderCardTest
-
This tests checks the right return of the method getMaterialType of the SpecialAbility of the LeaderCard class.
- testGetPointPos() - Method in class it.polimi.ingsw.model.faithtrack.BoxTest
-
This test checks the right behaviour of the testGetPointPos method.
- testGetPopeSpace() - Method in class it.polimi.ingsw.model.faithtrack.BoxTest
-
This test checks the right behaviour of the testGetPopeSpace method.
- testGetPosition() - Method in class it.polimi.ingsw.model.faithtrack.FaithTrackTest
-
This test checks the right behaviour of the testGetPosition method that returns the position on the faithTrack of a specified player
- testGetRequirements() - Method in class it.polimi.ingsw.model.leadercard.LeaderCardTest
-
This tests checks the right return of the method getVictoryPoint of the SpecialAbility of the LeaderCard class.
- testGetterOfLeaders() - Method in class it.polimi.ingsw.model.leadercard.LeaderCardTest
-
This tests checks the right behaviour of getter of the requirements of SpecialAbility of the LeaderCard class.
- testNewAdditionalDepositState() - Method in class it.polimi.ingsw.model.resource.ResourceHandlerTest
- testNewDepositState() - Method in class it.polimi.ingsw.model.resource.ResourceHandlerTest
- testSetPopeSpace() - Method in class it.polimi.ingsw.model.faithtrack.BoxTest
-
This test checks the right behaviour of the testSetPopeSpace method.
- testVictoryPoints() - Method in class it.polimi.ingsw.model.leadercard.LeaderCardTest
-
This tests checks the right return of the method getVictoryPoint of the SpecialAbility of the LeaderCard class.
- TotalResourceCounter - Class in it.polimi.ingsw.client.cli.views
-
This class prints the total count of resources possessed by the player for the buy of development card and the activation of development card
- TotalResourceCounter(Map<Resource, Integer>, ArrayList<Resource>, ArrayList<Resource>) - Constructor for class it.polimi.ingsw.client.cli.views.TotalResourceCounter
-
Constructor of the class initializes all the data structure
- TurnPlayedToServer - Class in it.polimi.ingsw.events.clienttoserver
-
This class represent the event send to the server for the choose of the type of turn.
- TurnPlayedToServer(String, String) - Constructor for class it.polimi.ingsw.events.clienttoserver.TurnPlayedToServer
-
Construct the event.
- TurnReselectionToClient - Class in it.polimi.ingsw.events.servertoclient
-
This class represents the event to send to the client for the reselection of the turn.
- TurnReselectionToClient(String) - Constructor for class it.polimi.ingsw.events.servertoclient.TurnReselectionToClient
-
Constructs the event.
- turnToView() - Method in class it.polimi.ingsw.controller.Controller
-
send to each player the current status of the match
All Classes|All Packages


Driver Registration
Licence Number:
First Name:
Last Name:
Physical Address:
Gender
-- Select --
-- Male --
-- Femae --
Nationality:
-- Select --
{{ national.name }}
Postal Box:
Birth Date:
National Id
Phone Number
Occupation
Expiring Date
Driving Class
**You can select more than one
Saving....
Saved Successful
Saving Failed
Saving....
Saved Successful
Saving Failed
Save
Update
Cancel


{% extends "layout.html" %} {% block content %}
The first step was to find or build a dataset of logos. A quick look on did not show any datasets of all industries, so Wikipedia was used to build a list.
There were four pages used to get listings of teams and brands with logos. Lists of brands List of sports teams List of Esports teams Lists of companies A web scraper was used to fetch lists of links and remove duplicate links. The first image on each article was downloaded and saved under a general category folder with the name of the page the image was pulled from. Images that were not logos or duplicates of logos were deleted manually. An additional dataset using demoscene logos was pulled from kaggle (link to dataset) Data Processing Logo categories simplified from their Wikipedia categories into 19 categories: Adult Alcohol Convenience Store Demoscene Dental/Pharmaceutical Electronics Esports Food/Drink Gaming Gas Media/Communications Misc Money Restaurant Software Sports Sports Clothing and Clothing Stores Utilities Smallest categories were the first to be merged into larger categories. Next, each logo was resized into 128x128 pngs to standardize them. The background color of each logo was determined by an algorithm that looked at the percentage of each color in the image and the color of edge pixels to fill extra space with an appropriate color. After the initial resizing, 16x16 images were made of all the logos. All of the smallest images have the logo in black and the background in white, as a way of focusing on the shape of the logo. Lastly, an input csv was made with the following columns: category Taken from the folder the logo was sorted into name Name of the image/Wikipedia page the logo was from. profile Portrait, landscape, or square - determined by image dimensions of the original images. number of colors variance r variance g variance b variance a Variance and number of colors help define logo styles. A simple, flat vector logo will have very few colors. Logos utilizing simple gradients or shading will generally a high color count, but will generally only have a high variance in R, G, B, or A. Monochromatic grey and black logos will have an equal R, G, and B variance. background color r background color g background color b background color a Determined by algorithm. primary color r primary color g primary color b primary color a secondary color r secondary color g secondary color b secondary color a tertiary color r tertiary color g tertiary color b tertiary color a Primary, tertiary, and secondary colors are calculated by percent_bg Information about shape. percent color1 percent color2 percent color3 Percentage the primary, secondary, and tertiary colors make up in the logo. imagedata_0... imagedata_255 0 or 1 input of the smallest version of the logo. Meant as a simple shape categorization. Training This was a lot of messing around and basically, lots of multiplying differences then standardizing them. Basically, once I put the imagedata in as a factor, it started thinking shape was REALLY important due to the number of variables. Wouldn't have had the slightest idea of how to make a convolutional net to isolate the features. But if I multiply the features that are more important, that ought to work right? And it did in the end. 65 clusters category, #"percent_bg", #"percent color1", #"percent color2", #"percent color3", were dropped in the end. Looking back, things I would have done differently: ratio instead of landscape, width, height, etc. Right now, due to the sheer number of inputs used to define "shape" it's kind of... weighed way more than everything else if I don't balance it out. Completely aware that "Red Square" and "Red Rectangle" ought be similar than red square and blue square, but that's not doing so well basicy tree, using whole image, for something like square/oval/circle with lots of generated data Difficulty with most image processing right now, a lot of the information looks like it's not so much for clustering - it's something you can optimize if you know the right answer. And what's more impotant for me, is that this is a pretty decent grouping. Is there text or not? - Font style if there is - incorporated into logo, serif/sans-serif/cursive text-shadow caps or no caps proporiton of letters and kerning round, square, text, irregular instead of images More logos that aren't blue text lines, and take out some blue lines of text logos. It's ridiculous how many there are - out of 65 clusters, they make up 3 fat clusters just by themselves. Is it a decent representation of what is out in the real world? Yes. Is it something people generally request of logo designers? No. average Line Width. This is something huge, stylistically, like font, but Future: Smarter dataset. Like it's nice that 9000000 blue logos is represenative of what most logos look like, but that's shit for brainstorming importance diagram Select only "representative" logos for selection Map shape using a trained net, then use that as an input If someone gets presented with all blue logos, that's not going to be helpful. Should find the most unique/represenative logos - subset of logos whose coordinates are most distant from any other logo in the dataset, and show examples from those {% endblock %}


Creates a Seq.
Returns a particular kind of Seq
based on the input.
Seq
, that same Seq
.Collection
, a Seq
of the same kind (Keyed, Indexed, or Set).Seq.Indexed
.Seq.Indexed
.Seq.Keyed
.Note: An Iterator itself will be treated as an object, becoming a Seq.Keyed
,
which is usually not what you want. You should turn your Iterator Object into
an iterable object by defining a Symbol.iterator (or @@iterator) method which
returns this
.
Note: Seq
is a conversion function and not a class, and does not use the
new
keyword during construction.
Seq
describes a lazy operation, allowing them to efficiently chain
use of all the higher-order collection methods (such as map
and filter
)
by not creating intermediate collections.
Seq is immutable — Once a Seq is created, it cannot be
changed, appended to, rearranged or otherwise modified. Instead, any
mutative method called on a Seq
will return a new Seq
.
Seq is lazy — Seq
does as little work as necessary to respond to any
method call. Values are often created during iteration, including implicit
iteration when reducing or converting to a concrete data structure such as
a List
or JavaScript Array
.
For example, the following performs no work, because the resulting
Seq
's values are never iterated:
const { Seq } = require('immutable')
const oddSquares = Seq([ 1, 2, 3, 4, 5, 6, 7, 8 ])
.filter(x => x % 2 !== 0)
.map(x => x * x)
Once the Seq
is used, it performs only the work necessary. In this
example, no intermediate arrays are ever created, filter is called three
times, and map is only called once:
oddSquares.get(1); // 9
Any collection can be converted to a lazy Seq with Seq()
.
const { Map } = require('immutable')
const map = Map({ a: 1, b: 2, c: 3 }
const lazySeq = Seq(map)
Seq
allows for the efficient chaining of operations, allowing for the
expression of logic that can otherwise be very tedious:
lazySeq
.flip()
.map(key => key.toUpperCase())
.flip()
// Seq { A: 1, B: 1, C: 1 }
As well as expressing logic that would otherwise seem memory or time
limited, for example Range
is a special kind of Lazy sequence.
const { Range } = require('immutable')
Range(1, Infinity)
.skip(1000)
.map(n => -n)
.filter(n => n % 2 === 0)
.take(2)
.reduce((r, n) => r * n, 1)
// 1006008
Seq is often used to provide a rich collection API to JavaScript Object.
Seq({ x: 0, y: 1, z: 2 }).map(v => v * 2).toObject();
// { x: 0, y: 2, z: 4 }
Seq
describes a lazy operation, allowing them to efficiently chain
use of all the higher-order collection methods (such as map
and filter
)
by not creating intermediate collections.
Seq is immutable — Once a Seq is created, it cannot be
changed, appended to, rearranged or otherwise modified. Instead, any
mutative method called on a Seq
will return a new Seq
.
Seq is lazy — Seq
does as little work as necessary to respond to any
method call. Values are often created during iteration, including implicit
iteration when reducing or converting to a concrete data structure such as
a List
or JavaScript Array
.
For example, the following performs no work, because the resulting
Seq
's values are never iterated:
const { Seq } = require('immutable')
const oddSquares = Seq([ 1, 2, 3, 4, 5, 6, 7, 8 ])
.filter(x => x % 2 !== 0)
.map(x => x * x)
Once the Seq
is used, it performs only the work necessary. In this
example, no intermediate arrays are ever created, filter is called three
times, and map is only called once:
oddSquares.get(1); // 9
Any collection can be converted to a lazy Seq with Seq()
.
const { Map } = require('immutable')
const map = Map({ a: 1, b: 2, c: 3 }
const lazySeq = Seq(map)
Seq
allows for the efficient chaining of operations, allowing for the
expression of logic that can otherwise be very tedious:
lazySeq
.flip()
.map(key => key.toUpperCase())
.flip()
// Seq { A: 1, B: 1, C: 1 }
As well as expressing logic that would otherwise seem memory or time
limited, for example Range
is a special kind of Lazy sequence.
const { Range } = require('immutable')
Range(1, Infinity)
.skip(1000)
.map(n => -n)
.filter(n => n % 2 === 0)
.take(2)
.reduce((r, n) => r * n, 1)
// 1006008
Seq is often used to provide a rich collection API to JavaScript Object.
Seq({ x: 0, y: 1, z: 2 }).map(v => v * 2).toObject();
// { x: 0, y: 2, z: 4 }
Seq
describes a lazy operation, allowing them to efficiently chain
use of all the higher-order collection methods (such as map
and filter
)
by not creating intermediate collections.
Seq is immutable — Once a Seq is created, it cannot be
changed, appended to, rearranged or otherwise modified. Instead, any
mutative method called on a Seq
will return a new Seq
.
Seq is lazy — Seq
does as little work as necessary to respond to any
method call. Values are often created during iteration, including implicit
iteration when reducing or converting to a concrete data structure such as
a List
or JavaScript Array
.
For example, the following performs no work, because the resulting
Seq
's values are never iterated:
const { Seq } = require('immutable')
const oddSquares = Seq([ 1, 2, 3, 4, 5, 6, 7, 8 ])
.filter(x => x % 2 !== 0)
.map(x => x * x)
Once the Seq
is used, it performs only the work necessary. In this
example, no intermediate arrays are ever created, filter is called three
times, and map is only called once:
oddSquares.get(1); // 9
Any collection can be converted to a lazy Seq with Seq()
.
const { Map } = require('immutable')
const map = Map({ a: 1, b: 2, c: 3 }
const lazySeq = Seq(map)
Seq
allows for the efficient chaining of operations, allowing for the
expression of logic that can otherwise be very tedious:
lazySeq
.flip()
.map(key => key.toUpperCase())
.flip()
// Seq { A: 1, B: 1, C: 1 }
As well as expressing logic that would otherwise seem memory or time
limited, for example Range
is a special kind of Lazy sequence.
const { Range } = require('immutable')
Range(1, Infinity)
.skip(1000)
.map(n => -n)
.filter(n => n % 2 === 0)
.take(2)
.reduce((r, n) => r * n, 1)
// 1006008
Seq is often used to provide a rich collection API to JavaScript Object.
Seq({ x: 0, y: 1, z: 2 }).map(v => v * 2).toObject();
// { x: 0, y: 2, z: 4 }
Seq
describes a lazy operation, allowing them to efficiently chain
use of all the higher-order collection methods (such as map
and filter
)
by not creating intermediate collections.
Seq is immutable — Once a Seq is created, it cannot be
changed, appended to, rearranged or otherwise modified. Instead, any
mutative method called on a Seq
will return a new Seq
.
Seq is lazy — Seq
does as little work as necessary to respond to any
method call. Values are often created during iteration, including implicit
iteration when reducing or converting to a concrete data structure such as
a List
or JavaScript Array
.
For example, the following performs no work, because the resulting
Seq
's values are never iterated:
const { Seq } = require('immutable')
const oddSquares = Seq([ 1, 2, 3, 4, 5, 6, 7, 8 ])
.filter(x => x % 2 !== 0)
.map(x => x * x)
Once the Seq
is used, it performs only the work necessary. In this
example, no intermediate arrays are ever created, filter is called three
times, and map is only called once:
oddSquares.get(1); // 9
Any collection can be converted to a lazy Seq with Seq()
.
const { Map } = require('immutable')
const map = Map({ a: 1, b: 2, c: 3 }
const lazySeq = Seq(map)
Seq
allows for the efficient chaining of operations, allowing for the
expression of logic that can otherwise be very tedious:
lazySeq
.flip()
.map(key => key.toUpperCase())
.flip()
// Seq { A: 1, B: 1, C: 1 }
As well as expressing logic that would otherwise seem memory or time
limited, for example Range
is a special kind of Lazy sequence.
const { Range } = require('immutable')
Range(1, Infinity)
.skip(1000)
.map(n => -n)
.filter(n => n % 2 === 0)
.take(2)
.reduce((r, n) => r * n, 1)
// 1006008
Seq is often used to provide a rich collection API to JavaScript Object.
Seq({ x: 0, y: 1, z: 2 }).map(v => v * 2).toObject();
// { x: 0, y: 2, z: 4 }
Seq
describes a lazy operation, allowing them to efficiently chain
use of all the higher-order collection methods (such as map
and filter
)
by not creating intermediate collections.
Seq is immutable — Once a Seq is created, it cannot be
changed, appended to, rearranged or otherwise modified. Instead, any
mutative method called on a Seq
will return a new Seq
.
Seq is lazy — Seq
does as little work as necessary to respond to any
method call. Values are often created during iteration, including implicit
iteration when reducing or converting to a concrete data structure such as
a List
or JavaScript Array
.
For example, the following performs no work, because the resulting
Seq
's values are never iterated:
const { Seq } = require('immutable')
const oddSquares = Seq([ 1, 2, 3, 4, 5, 6, 7, 8 ])
.filter(x => x % 2 !== 0)
.map(x => x * x)
Once the Seq
is used, it performs only the work necessary. In this
example, no intermediate arrays are ever created, filter is called three
times, and map is only called once:
oddSquares.get(1); // 9
Any collection can be converted to a lazy Seq with Seq()
.
const { Map } = require('immutable')
const map = Map({ a: 1, b: 2, c: 3 }
const lazySeq = Seq(map)
Seq
allows for the efficient chaining of operations, allowing for the
expression of logic that can otherwise be very tedious:
lazySeq
.flip()
.map(key => key.toUpperCase())
.flip()
// Seq { A: 1, B: 1, C: 1 }
As well as expressing logic that would otherwise seem memory or time
limited, for example Range
is a special kind of Lazy sequence.
const { Range } = require('immutable')
Range(1, Infinity)
.skip(1000)
.map(n => -n)
.filter(n => n % 2 === 0)
.take(2)
.reduce((r, n) => r * n, 1)
// 1006008
Seq is often used to provide a rich collection API to JavaScript Object.
Seq({ x: 0, y: 1, z: 2 }).map(v => v * 2).toObject();
// { x: 0, y: 2, z: 4 }
Seq
describes a lazy operation, allowing them to efficiently chain
use of all the higher-order collection methods (such as map
and filter
)
by not creating intermediate collections.
Seq is immutable — Once a Seq is created, it cannot be
changed, appended to, rearranged or otherwise modified. Instead, any
mutative method called on a Seq
will return a new Seq
.
Seq is lazy — Seq
does as little work as necessary to respond to any
method call. Values are often created during iteration, including implicit
iteration when reducing or converting to a concrete data structure such as
a List
or JavaScript Array
.
For example, the following performs no work, because the resulting
Seq
's values are never iterated:
const { Seq } = require('immutable')
const oddSquares = Seq([ 1, 2, 3, 4, 5, 6, 7, 8 ])
.filter(x => x % 2 !== 0)
.map(x => x * x)
Once the Seq
is used, it performs only the work necessary. In this
example, no intermediate arrays are ever created, filter is called three
times, and map is only called once:
oddSquares.get(1); // 9
Any collection can be converted to a lazy Seq with Seq()
.
const { Map } = require('immutable')
const map = Map({ a: 1, b: 2, c: 3 }
const lazySeq = Seq(map)
Seq
allows for the efficient chaining of operations, allowing for the
expression of logic that can otherwise be very tedious:
lazySeq
.flip()
.map(key => key.toUpperCase())
.flip()
// Seq { A: 1, B: 1, C: 1 }
As well as expressing logic that would otherwise seem memory or time
limited, for example Range
is a special kind of Lazy sequence.
const { Range } = require('immutable')
Range(1, Infinity)
.skip(1000)
.map(n => -n)
.filter(n => n % 2 === 0)
.take(2)
.reduce((r, n) => r * n, 1)
// 1006008
Seq is often used to provide a rich collection API to JavaScript Object.
Seq({ x: 0, y: 1, z: 2 }).map(v => v * 2).toObject();
// { x: 0, y: 2, z: 4 }
Some Seqs can describe their size lazily. When this is the case, size will be an integer. Otherwise it will be undefined.
For example, Seqs returned from map()
or reverse()
preserve the size of the original Seq
while filter()
does not.
Note: Range
, Repeat
and Seq
s made from Array
s and Object
s will
always have a size.
True if maybeSeq
is a Seq, it is not backed by a concrete
structure such as Map, List, or Set.
Creates a Collection.
The type of Collection created is based on the input.
Collection
, that same Collection
.Collection.Indexed
.Collection.Indexed
.Collection.Keyed
.This methods forces the conversion of Objects and Strings to Collections.
If you want to ensure that a Collection of one item is returned, use
Seq.of
.
Note: An Iterator itself will be treated as an object, becoming a Seq.Keyed
,
which is usually not what you want. You should turn your Iterator Object into
an iterable object by defining a Symbol.iterator (or @@iterator) method which
returns this
.
Note: Collection
is a conversion function and not a class, and does not
use the new
keyword during construction.
Returns a new Collection of the same type containing all entries except the last.
 For example, this map function is called a total
of 6 times, as each join
iterates the Seq of three values.
var squares = Seq([ 1, 2, 3 ]).map(x => x * x)
squares.join() + squares.join()
If you know a Seq
will be used multiple times, it may be more
efficient to first cache it in memory. Here, the map function is called
only 3 times.
var squares = Seq([ 1, 2, 3 ]).map(x => x * x).cacheResult()
squares.join() + squares.join()
Use this method judiciously, as it must fully evaluate a Seq which can be a burden on memory and possibly performance.
Note: after calling cacheResult
, a Seq will always have a size
.
Returns a new Collection of the same type with other values and collection-like concatenated to this one.
For Seqs, all entries will be present in the resulting Seq, even if they have the same key.
Returns the size of this Collection.
Regardless of if this Collection can describe its size lazily (some Seqs
cannot), this method will always return the correct size. E.g. it
evaluates a lazy Seq
if necessary.
If predicate
is provided, then this returns the count of entries in the
Collection for which the predicate
returns true.
Returns a Seq.Keyed
of counts, grouped by the return value of
the grouper
function.
Note: This is not a lazy operation.
An iterator of this Collection
's entries as [ key, value ]
tuples.
Note: this will return an ES6 iterator which does not support
Immutable.js sequence algorithms. Use entrySeq
instead, if this is
what you want.
Returns a new Seq.Indexed of [key, value] tuples.
True if this and the other Collection have value equality, as defined
by Immutable.is()
.
Note: This is equivalent to Immutable.is(this, other)
, but provided to
allow for chained expressions.
True if predicate
returns true for all entries in the Collection.
Returns a new Seq with only the values for which the predicate
function returns true.
Note: filter()
always returns a new instance, even if it results in
not filtering out any values.
Returns a new Collection of the same type with only the entries for which
the predicate
function returns false.
const { Map } = require('immutable')
Map({ a: 1, b: 2, c: 3, d: 4}).filterNot(x => x % 2 === 0)
// Map { "a": 1, "c": 3 }
Note: filterNot()
always returns a new instance, even if it results in
not filtering out any values.
Returns the first value for which the predicate
returns true.
Returns the first [key, value] entry for which the predicate
returns true.
Returns the key for which the predicate
returns true.
Returns the last value for which the predicate
returns true.
Note: predicate
will be called for each entry in reverse.
Returns the last [key, value] entry for which the predicate
returns true.
Note: predicate
will be called for each entry in reverse.
Returns the last key for which the predicate
returns true.
Note: predicate
will be called for each entry in reverse.
In case the Collection
is not empty returns the first element of the
Collection
.
In case the Collection
is empty returns the optional default
value if provided, if no default value is provided returns undefined.
Flat-maps the Seq, returning a Seq of the same type.
Similar to seq.map(...).flatten(true)
.
Flat-maps the Seq, returning a Seq of the same type.
Similar to seq.map(...).flatten(true)
.
Note: Used only for sets.
Flattens nested Collections.
Will deeply flatten the Collection by default, returning a Collection of the
same type, but a depth
can be provided in the form of a number or
boolean (where true means to shallowly flatten one level). A depth of 0
(or shallow: false) will deeply flatten.
Flattens only others Collection, not Arrays or Objects.
Note: flatten(true)
operates on Collection<any, Collection<K, V>> and
returns Collection<K, V>
The sideEffect
is executed for every entry in the Collection.
Unlike Array#forEach
, if any call of sideEffect
returns
false
, the iteration will stop. Returns the number of entries iterated
(including the last iteration which returned false).
Returns the value associated with the provided key, or notSetValue if the Collection does not contain this key.
Note: it is possible a key may be associated with an undefined
value,
so if notSetValue
is not provided and this method returns undefined
,
that does not guarantee the key was not found.
Returns the value found by following a path of keys or indices through nested Collections.
const { Map, List } = require('immutable')
const deepData = Map({ x: List([ Map({ y: 123 }) ]) });
deepData.getIn(['x', 0, 'y']) // 123
Plain JavaScript Object or Arrays may be nested within an Immutable.js Collection, and getIn() can access those values as well:
const { Map, List } = require('immutable')
const deepData = Map({ x: [ { y: 123 } ] });
deepData.getIn(['x', 0, 'y']) // 123
Returns a Collection.Keyed
of Collection.Keyeds
, grouped by the return
value of the grouper
function.
Note: This is always an eager operation.
const { List, Map } = require('immutable')
const listOfMaps = List([
Map({ v: 0 }),
Map({ v: 1 }),
Map({ v: 1 }),
Map({ v: 0 }),
Map({ v: 2 })
])
const groupsOfMaps = listOfMaps.groupBy(x => x.get('v'))
// Map {
// 0: List [ Map{ "v": 0 }, Map { "v": 0 } ],
// 1: List [ Map{ "v": 1 }, Map { "v": 1 } ],
// 2: List [ Map{ "v": 2 } ],
// }
True if a key exists within this Collection
, using Immutable.is
to determine equality
True if the result of following a path of keys or indices through nested Collections results in a set value.
Computes and returns the hashed identity for this Collection.
The hashCode
of a Collection is used to determine potential equality,
and is used when adding this to a Set
or as a key in a Map
, enabling
lookup via a different instance.
const a = List([ 1, 2, 3 ]);
const b = List([ 1, 2, 3 ]);
assert.notStrictEqual(a, b); // different instances
const set = Set([ a ]);
assert.equal(set.has(b), true);
If two values have the same hashCode
, they are not guaranteed
to be equal. If two values have different hashCode
s,
they must not be equal.
True if a value exists within this Collection
, using Immutable.is
to determine equality
Returns true if this Collection includes no values.
For some lazy Seq
, isEmpty
might need to iterate to determine
emptiness. At most one iteration will occur.
True if iter
includes every value in this Collection.
True if this Collection includes every value in iter
.
Joins values together as a string, inserting a separator between each.
The default separator is ","
.
Returns the key associated with the search value, or undefined.
Returns a new Seq.Indexed of the keys of this Collection, discarding values.
An iterator of this Collection
's keys.
Note: this will return an ES6 iterator which does not support
Immutable.js sequence algorithms. Use keySeq
instead, if this is
what you want.
In case the Collection
is not empty returns the last element of the
Collection
.
In case the Collection
is empty returns the optional default
value if provided, if no default value is provided returns undefined.
Returns the last key associated with the search value, or undefined.
Returns a new Seq with values passed through a
mapper
function.
const { Seq } = require('immutable')
Seq([ 1, 2 ]).map(x => 10 * x)
// Seq [ 10, 20 ]
Note: map()
always returns a new instance, even if it produced the same
value at every step.
Returns a new Seq with values passed through a
mapper
function.
const { Seq } = require('immutable')
Seq([ 1, 2 ]).map(x => 10 * x)
// Seq [ 10, 20 ]
Note: map()
always returns a new instance, even if it produced the same
value at every step.
Note: used only for sets.
Returns the maximum value in this collection. If any values are comparatively equivalent, the first one found will be returned.
The comparator
is used in the same way as Collection#sort
. If it is not
provided, the default comparator is >
.
When two values are considered equivalent, the first encountered will be
returned. Otherwise, max
will operate independent of the order of input
as long as the comparator is commutative. The default comparator >
is
commutative only when types do not differ.
If comparator
returns 0 and either value is NaN, undefined, or null,
that value will be returned.
Like max
, but also accepts a comparatorValueMapper
which allows for
comparing by more sophisticated means:
hitters.maxBy(hitter => hitter.avgHits);
Returns the minimum value in this collection. If any values are comparatively equivalent, the first one found will be returned.
The comparator
is used in the same way as Collection#sort
. If it is not
provided, the default comparator is <
.
When two values are considered equivalent, the first encountered will be
returned. Otherwise, min
will operate independent of the order of input
as long as the comparator is commutative. The default comparator <
is
commutative only when types do not differ.
If comparator
returns 0 and either value is NaN, undefined, or null,
that value will be returned.
Like min
, but also accepts a comparatorValueMapper
which allows for
comparing by more sophisticated means:
hitters.minBy(hitter => hitter.avgHits);
Reduces the Collection to a value by calling the reducer
for every entry
in the Collection and passing along the reduced value.
If initialReduction
is not provided, the first item in the
Collection will be used.
Reduces the Collection in reverse (from the right side).
Note: Similar to this.reverse().reduce(), and provided for parity
with Array#reduceRight
.
Returns a new Collection of the same type containing all entries except the first.
Returns a new Collection of the same type in reverse order.
Returns a new Collection of the same type which excludes the first amount
entries from this Collection.
Returns a new Collection of the same type which excludes the last amount
entries from this Collection.
Returns a new Collection of the same type which includes entries starting
from when predicate
first returns true.
const { List } = require('immutable')
List([ 'dog', 'frog', 'cat', 'hat', 'god' ])
.skipUntil(x => x.match(/hat/))
// List [ "hat", "god"" ]
Returns a new Collection of the same type which includes entries starting
from when predicate
first returns false.
const { List } = require('immutable')
List([ 'dog', 'frog', 'cat', 'hat', 'god' ])
.skipWhile(x => x.match(/g/))
// List [ "cat", "hat", "god"" ]
Returns a new Collection of the same type representing a portion of this Collection from start up to but not including end.
If begin is negative, it is offset from the end of the Collection. e.g.
slice(-2)
returns a Collection of the last two entries. If it is not
provided the new Collection will begin at the beginning of this Collection.
If end is negative, it is offset from the end of the Collection. e.g.
slice(0, -1)
returns a Collection of everything but the last entry. If
it is not provided, the new Collection will continue through the end of
this Collection.
If the requested slice is equivalent to the current Collection, then it will return itself.
True if predicate
returns true for any entry in the Collection.
Returns a new Collection of the same type which includes the same entries,
stably sorted by using a comparator
.
If a comparator
is not provided, a default comparator uses <
and >
.
comparator(valueA, valueB)
:
0
if the elements should not be swapped.-1
(or any negative number) if valueA
comes before valueB
1
(or any positive number) if valueA
comes after valueB
When sorting collections which have no defined order, their ordered
equivalents will be returned. e.g. map.sort()
returns OrderedMap.
const { Map } = require('immutable')
Map({ "c": 3, "a": 1, "b": 2 }).sort((a, b) => {
if (a < b) { return -1; }
if (a > b) { return 1; }
if (a === b) { return 0; }
});
// OrderedMap { "a": 1, "b": 2, "c": 3 }
Note: sort()
Always returns a new instance, even if the original was
already sorted.
Note: This is always an eager operation.
Like sort
, but also accepts a comparatorValueMapper
which allows for
sorting by more sophisticated means:
hitters.sortBy(hitter => hitter.avgHits)
Note: sortBy()
Always returns a new instance, even if the original was
already sorted.
Note: This is always an eager operation.
Returns a new Collection of the same type which includes the first amount
entries from this Collection.
Returns a new Collection of the same type which includes the last amount
entries from this Collection.
Returns a new Collection of the same type which includes entries from this
Collection as long as the predicate
returns false.
const { List } = require('immutable')
List([ 'dog', 'frog', 'cat', 'hat', 'god' ])
.takeUntil(x => x.match(/at/))
// List [ "dog", "frog" ]
Returns a new Collection of the same type which includes entries from this
Collection as long as the predicate
returns true.
const { List } = require('immutable')
List([ 'dog', 'frog', 'cat', 'hat', 'god' ])
.takeWhile(x => x.match(/o/))
// List [ "dog", "frog" ]
Shallowly converts this collection to an Array.
Collection.Indexed
, and Collection.Set
produce an Array of values.
Collection.Keyed
produce an Array of [key, value] tuples.
Returns an Seq.Indexed of the values of this Collection, discarding keys.
Deeply converts this Collection to equivalent native JavaScript Array or Object.
Collection.Indexed
, and Collection.Set
become Array
, while
Collection.Keyed
become Object
, converting keys to Strings.
Shallowly converts this Collection to equivalent native JavaScript Array or Object.
Collection.Indexed
, and Collection.Set
become Array
, while
Collection.Keyed
become Object
, converting keys to Strings.
Returns a Seq.Keyed from this Collection where indices are treated as keys.
This is useful if you want to operate on an Collection.Indexed and preserve the [index, value] pairs.
The returned Seq will have identical iteration order as this Collection.
const { Seq } = require('immutable')
const indexedSeq = Seq([ 'A', 'B', 'C' ])
// Seq [ "A", "B", "C" ]
indexedSeq.filter(v => v === 'B')
// Seq [ "B" ]
const keyedSeq = indexedSeq.toKeyedSeq()
// Seq { 0: "A", 1: "B", 2: "C" }
keyedSeq.filter(v => v === 'B')
// Seq { 1: "B" }
Converts this Collection to a List, discarding keys.
This is similar to List(collection)
, but provided to allow for chained
expressions. However, when called on Map
or other keyed collections,
collection.toList()
discards the keys and creates a list of only the
values, whereas List(collection)
creates a list of entry tuples.
const { Map, List } = require('immutable')
var myMap = Map({ a: 'Apple', b: 'Banana' })
List(myMap) // List [ [ "a", "Apple" ], [ "b", "Banana" ] ]
myMap.toList() // List [ "Apple", "Banana" ]
Converts this Collection to a Map, Throws if keys are not hashable.
Note: This is equivalent to Map(this.toKeyedSeq())
, but provided
for convenience and to allow for chained expressions.
Shallowly converts this Collection to an Object.
Converts keys to Strings.
Converts this Collection to a Map, maintaining the order of iteration.
Note: This is equivalent to OrderedMap(this.toKeyedSeq())
, but
provided for convenience and to allow for chained expressions.
Converts this Collection to a Set, maintaining the order of iteration and discarding keys.
Note: This is equivalent to OrderedSet(this.valueSeq())
, but provided
for convenience and to allow for chained expressions.
Converts this Collection to a Seq of the same kind (indexed, keyed, or set).
Converts this Collection to a Set, discarding keys. Throws if values are not hashable.
Note: This is equivalent to Set(this)
, but provided to allow for
chained expressions.
Returns a Seq.Set of the values of this Collection, discarding keys.
Converts this Collection to a Stack, discarding keys. Throws if values are not hashable.
Note: This is equivalent to Stack(this)
, but provided to allow for
chained expressions.
This can be very useful as a way to "chain" a normal function into a sequence of methods. RxJS calls this "let" and lodash calls it "thru".
For example, to sum a Seq after mapping and filtering:
const { Seq } = require('immutable')
function sum(collection) {
return collection.reduce((sum, x) => sum + x, 0)
}
Seq([ 1, 2, 3 ])
.map(x => x + 1)
.filter(x => x % 2 === 0)
.update(sum)
// 6
Returns an Seq.Indexed of the values of this Collection, discarding keys.
An iterator of this Collection
's values.
Note: this will return an ES6 iterator which does not support
Immutable.js sequence algorithms. Use valueSeq
instead, if this is
what you want.
Generated using TypeDoc
Seq
describes a lazy operation, allowing them to efficiently chain use of all the higher-order collection methods (such asmap
andfilter
) by not creating intermediate collections.Seq is immutable — Once a Seq is created, it cannot be changed, appended to, rearranged or otherwise modified. Instead, any mutative method called on a
Seq
will return a newSeq
.Seq is lazy —
Seq
does as little work as necessary to respond to any method call. Values are often created during iteration, including implicit iteration when reducing or converting to a concrete data structure such as aList
or JavaScriptArray
.For example, the following performs no work, because the resulting
Seq
's values are never iterated:const { Seq } = require('immutable') const oddSquares = Seq([ 1, 2, 3, 4, 5, 6, 7, 8 ]) .filter(x => x % 2 !== 0) .map(x => x * x)
Once the
Seq
is used, it performs only the work necessary. In this example, no intermediate arrays are ever created, filter is called three times, and map is only called once:oddSquares.get(1); // 9
Any collection can be converted to a lazy Seq with
Seq()
.const { Map } = require('immutable') const map = Map({ a: 1, b: 2, c: 3 } const lazySeq = Seq(map)
Seq
allows for the efficient chaining of operations, allowing for the expression of logic that can otherwise be very tedious:lazySeq .flip() .map(key => key.toUpperCase()) .flip() // Seq { A: 1, B: 1, C: 1 }
As well as expressing logic that would otherwise seem memory or time limited, for example
Range
is a special kind of Lazy sequence.const { Range } = require('immutable') Range(1, Infinity) .skip(1000) .map(n => -n) .filter(n => n % 2 === 0) .take(2) .reduce((r, n) => r * n, 1) // 1006008
Seq is often used to provide a rich collection API to JavaScript Object.
Seq({ x: 0, y: 1, z: 2 }).map(v => v * 2).toObject(); // { x: 0, y: 2, z: 4 }


"""Configure Test Suite.
This file is used to configure the behavior of pytest when using the Astropy
test infrastructure. It needs to live inside the package in order for it to
get picked up when running the tests inside an interpreter using
packagename.test
"""
import os
from astropy.version import version as astropy_version
# For Astropy 3.0 and later, we can use the standalone pytest plugin
if astropy_version < '3.0':
from astropy.tests.pytest_plugins import * # noqa
del pytest_report_header
else:
try:
from pytest_astropy_header.display import PYTEST_HEADER_MODULES, TESTED_VERSIONS
ASTROPY_HEADER = True
except ImportError:
ASTROPY_HEADER = False
# Uncomment the last two lines in this block to treat all DeprecationWarnings as
# exceptions. For Astropy v2.0 or later, there are 2 additional keywords,
# as follow (although default should work for most cases).
# To ignore some packages that produce deprecation warnings on import
# (in addition to 'compiler', 'scipy', 'pygments', 'ipykernel', and
# 'setuptools'), add:
# modules_to_ignore_on_import=['module_1', 'module_2']
# To ignore some specific deprecation warning messages for Python version
# MAJOR.MINOR or later, add:
# warnings_to_ignore_by_pyver={(MAJOR, MINOR): ['Message to ignore']}
# from astropy.tests.helper import enable_deprecations_as_exceptions # noqa
# enable_deprecations_as_exceptions()


Test Synbiohub
Submit
Shared with Me
Submissions
Admin
Profile
Sign Out
Home
Test Synbiohub
text
Search
for useful parts and designs
Search
Browse Design Collections
Upload
your design for safekeeping
Submit a Design
Share
designs for publication or collaboration
Manage Submissions


--- title: The Spherical Bingham Distribution sidebar: documentation_sidebar permalink: S2FunBingham.html folder: documentation toc: false ---
The Bingham distribution on the sphere is an antipodal symmetric distribution (Bingham, 1974) with a probabiliy density function given by
\[p_{b}(\hat{x}\vert AKA^T) = \frac{1}{F(\kappa_{1},\kappa_{2},\kappa_{3})}\exp (\hat{x}^T AZA^T \hat{x})\]
where \(A\) is an orthognal covariance matrix, and \(Z\) a concentration matrix with \(\diag(\kappa_{1},\kappa_{2},\kappa_{3})\) with \(\kappa_{1} < \kappa_{2} < \kappa_{3}\).
In mtex \(Z\) is given by Z = [k1,k2,k3]
with k3 = 0
and \(A\) is given by three orthognal vectors.
\(k1 = k2\) defines a rotationally symmetric point maximum and \(k2 = 0\) defines a girdle distribution.
{% highlight matlab %} close kappa = [0 4 8 12 24]; mtexFig = newMtexFigure('layout',[length(kappa) length(kappa)]); for k2 = kappa for k1 = kappa if k1 >= k2 bs=BinghamS2([-k1 -k2 0]); plot(bs,'colorRange',[0,25],'TR',[{'\(\kappa_1 :\)'} ; num2str(k1)],'BR',[{'\(\kappa_2 :\)'} ; num2str(k2)]) % mtexTitle(['\(\kappa_1 :\)' num2str(k1) ' ' '\(\kappa_2 :\)' num2str(k2)],'FontSize',14) nextAxis else nextAxis end end end CLim(mtexFig,'equal') mtexFig.drawNow; {% endhighlight %}Given arbitrarily scattered data v
on the sphere we can estimate the best fitting Bingham distribution by
Lets plot the fitted distribution with the data
{% highlight matlab %} plot(bs) hold on plot(v,'MarkerFaceColor','Black') hold off {% endhighlight %}Under the assumption of sufficiently many and sufficently concetrated data we may also estimate a confidence ellipse for the mean direction (default p = 0.95). The center of the ellipse is given by the largest principle vector stored in bs.a(3)
The orientation of the ellipse is specified by all the principle vectors bs.a
and the a and b axes are computed by the command cEllipse


About
I'm a desinger with 5 years of experience in web-based application, I love research human behaviour through observation and some objective measure such as eye-tracking or other usability testing methods. I always believe designer couldn't make users satisfied before totally realize them.
Aside from designing product, I love photography and marathon, and translation.


— Brian Moeskau (@bmoeskau)
— Sherwin Sim
Thanks to our venue:
Thanks to our sponsor:
| 63 | 58 | 16 | 11 |
| 63 64 |
58 | 16 | 11 11.1 |
Released Jan 25 — Release Notes
Released Jan 25 — Release Notes
TC39 proposals implemented:
const ro = new ResizeObserver(item => {
item.target.style.borderRadius =
Math.max(0, 250 - item.contentRect.width) + 'px';
});
ro.observe(document.querySelector('.some-item'));
Released Jan 24 — Release Notes
Free e-book (or support it) by Dr. Axel Rauschmayer
Released February 5th
A toolkit for universal, server-rendered React applications
Released February 14th
Released February 21st
Build cross platform desktop apps with JavaScript, HTML, and CSS
Released February 24th
A JS library for handling Force Touch, 3D Touch, and Pointer Pressure on the web
Chrome 65 will no longer trust Symantec-issed SSL certificates older than June 1, 2016
Symantec had entrusted several organizations with the ability to issue certificates without the appropriate or necessary oversight, and had been aware of security deficiencies at these organizations for some time.
A free database of 501,636,842 known compromised passwords
Mega interview (2.5 hours!) with framework all-stars
Updates on latest framework features
Easily the best React counter you'll find anywhere on Altavista.
import RetroHitCounter from 'react-retro-hit-counter';
const counter = () => (
<RetroHitCounter hits={1337} />
);
Make sure you check out the demo page
An open source remake of SimCity 2000 written in JS using HTML5 Canvas, SQLite and built on Electron.
An JavaScript NES emulator for the browser and Node.
Play the online demos
/
#


Class RTSPServer
Inheritance
System.Object
RTSPServer
Inherited Members
System.Object.Equals(System.Object)
System.Object.Equals(System.Object, System.Object)
System.Object.GetHashCode()
System.Object.GetType()
System.Object.MemberwiseClone()
System.Object.ReferenceEquals(System.Object, System.Object)
System.Object.ToString()
Namespace: SIPSorcery.Net
Assembly: SIPSorcery.dll
Syntax
public class RTSPServer
Constructors
| Improve this Doc View SourceRTSPServer(IPEndPoint)
Declaration
public RTSPServer(IPEndPoint endPoint)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Net.IPEndPoint | endPoint |
Fields
| Improve this Doc View SourceClosed
Declaration
public bool Closed
Field Value
| Type | Description |
|---|---|
| System.Boolean |
RTSPClientMessageReceived
Declaration
public Action<RTSPConnection, IPEndPoint, byte[]> RTSPClientMessageReceived
Field Value
| Type | Description |
|---|---|
| System.Action<RTSPConnection, System.Net.IPEndPoint, System.Byte[]> |
RTSPClientSocketDisconnected
Declaration
public Action<IPEndPoint> RTSPClientSocketDisconnected
Field Value
| Type | Description |
|---|---|
| System.Action<System.Net.IPEndPoint> |
Properties
| Improve this Doc View SourceLocalEndPoint
Declaration
public IPEndPoint LocalEndPoint { get; }
Property Value
| Type | Description |
|---|---|
| System.Net.IPEndPoint |
Methods
| Improve this Doc View SourceClose()
Closes the RTSP server socket as well as any open sessions.
Declaration
public void Close()
CreateRTSPSession(IPEndPoint, IPEndPoint)
Creates a new RTSP session and intialises the RTP and control sockets for the session.
Declaration
public RTSPSession CreateRTSPSession(IPEndPoint remoteEndPoint, IPEndPoint rtcpRemoteEndPoint)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Net.IPEndPoint | remoteEndPoint | The remote end point of the RTSP client that requested the RTSP session be set up. |
| System.Net.IPEndPoint | rtcpRemoteEndPoint |
Returns
| Type | Description |
|---|---|
| RTSPSession | An RTSP session object. |
IsConnectionEstablished(IPEndPoint)
Declaration
public bool IsConnectionEstablished(IPEndPoint remoteEndPoint)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Net.IPEndPoint | remoteEndPoint |
Returns
| Type | Description |
|---|---|
| System.Boolean |
Send(IPEndPoint, Byte[])
Sends data to the RTSP client listening on the destination end point.
Declaration
public void Send(IPEndPoint dstEndPoint, byte[] buffer)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Net.IPEndPoint | dstEndPoint | |
| System.Byte[] | buffer | The data to send. |
Send(IPEndPoint, String)
Sends a message to the RTSP client listening on the destination end point.
Declaration
public void Send(IPEndPoint destinationEndPoint, string message)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Net.IPEndPoint | destinationEndPoint | The destination to send the message to. |
| System.String | message | The message to send. |


Style Guide
Overview
base
color
color
src/assets/sass/foundation/variable/_color.scss
common site color palette
primary
#d6101c
secondary
#fd3a45
thirdry-color
#00a0e9
white
#fafafa
black
#3f3a39
gray
#424242
light-gray
#d6d3cd


404: Page Not Found. The game may not exist or be terminated. Click the link to return to the login page.


You are saving this photo to : {{save.folder ? save.folder.name : 'No place yet!' }}
Go To Projects to Create a New Folder


Params
| Variable | Description |
|---|---|
{{params.today}}
|
today's date as
YYYY-MM-DD
|
{{params.yesterday}}
|
yesterday's date as
YYYY-MM-DD
|
{{params.this_month}}
|
this month as
YYYY-MM
|
{{params.this_month_first_day}}
|
the first day of this month's date as
YYYY-MM-DD
|
{{params.this_month_last_day}}
|
the last day of this month's as
YYYY-MM-DD
|
{{params.last_month}}
|
last month as
YYYY-MM
|
{{params.last_month_first_day}}
|
the first day of last month's date as
YYYY-MM-DD
|
{{params.last_month_last_day}}
|
the last day of last month's as
YYYY-MM-DD
|


A performative commentary on Climate Migration, the loss of land and identity represented by the physical distance and distortion of the human body.
Environmental migrants are persons or groups of persons who, for compelling reasons of sudden or progressive changes in the environment that adversely affect their lives or living conditions, are obliged to leave their habitual homes, or choose to do so, either temporarily or permanently, and who move either within their country or abroad.
Environmental migrants are persons or groups of persons who, for compelling reasons of sudden or progressive changes in the environment that adversely affect their lives or living conditions, are obliged to leave their habitual homes, or choose to do so, either temporarily or permanently, and who move either within their country or abroad.
Since climate migrants are not internationally recognized as 'refugees', they may expreience what is called 'Statelessness' - the phenomenon of not having a state (for international migration, mostly in island countries), losing both their Land and Identity. I am using food as a metaphor to talk about this phenomenon.
Since climate migrants are not internationally recognized as 'refugees', they may expreience what is called 'Statelessness' - the phenomenon of not having a state (for international migration, mostly in island countries), losing both their Land and Identity. I am using food as a metaphor to talk about this phenomenon.
In the performance, the finger sculptures get more disfigured with every meal the performer eats - representing a migrant's increasing dysmorphic distance from their land and food. The physical distortion of the human body is compelling and feels real to the observer.
These finger sculptures used in the performance belong to different migrants and are made using silicone casting in an alginate mould.
These finger sculptures used in the performance belong to different migrants and are made using silicone casting in an alginate mould.


In order to use Stevenson, you must first authenticate with your GitHub.
Don't have a GitHub account? Create one here!


{{ define "main" }}
We will use the information you provide on this form to email you our monthly newsletter and other updates. Unsubscribe at any time!
Posted: {{ dateFormat "02/01/06" .Date }} | Expires: {{ dateFormat "02/01/06" .ExpiryDate }}
{{ .Description }}
Continue reading!


{% extends "base.html" %} {% block title %}Internal Server Error{% endblock %} {% block pagetitle %}
We're sorry. There's a server error and we're working on it.


Immunotoxicity of Both Nondegraded and Biodegraded Polychlorinated Biphenyls (PCBs)
EPA Grant Number: R826687Title: Immunotoxicity of Both Nondegraded and Biodegraded Polychlorinated Biphenyls (PCBs)
Investigators: London, Lucille
Current Investigators: London, Lucille , Morris, Pamela , Quensen, John , Smithwick, Laura Ashley
Institution: Medical University of South Carolina
EPA Project Officer: Deener, Kacee
Project Period: September 15, 1998 through September 14, 2001
Project Amount: $379,176
RFA: Exploratory Research - Human Health (1998) RFA Text | Recipients Lists
Research Category: Health Effects , Human Health , Health
Description:
The long term goal of our laboratory is to understand the biological process by which complex mixtures of contaminants can be degraded in the environment and to apply that knowledge to better understand potential human health effects associated with exposure. We will focus on the biodegradation of complex mixtures of polychlorinated biphenyls (PCBs) and their subsequent immunotoxicological effects on parameters of immune lymphocyte function. The potential for existing and newly emerging bioremediation technologies to treat complex waste sites is based upon their ability to remove these chemicals from contaminated environments. However, there has been little attempt to correlate disappearance of contaminated material with a discernible decrease in the health hazards associated with biotreated materials.
PCBs are wide spread environmental contaminants and available evidence suggests that the immune system is a target for PCBs toxicity (1-5). Thus, the persistence of PCBs in the environment and their bioaccumulation in living organisms raises concerns regarding their immunotoxic potential and subsequent effects on health. In preliminary studies, we have shown that complex mixtures of PCBs (Aroclors) which have been used industrially and are known environmental contaminants have immunotoxic effects on lymphocytes in an in vitro assay system. We hypothesize that the immunotoxicity of biodegraded PCBs will be lower than the immunotoxicity of the commercial mixtures since the biodegradation process results in the dechlorination of the PCB mixture and an association of increased immunotoxicity in vivo and in our in vitro proliferation assay correlates with more heavily chlorinated PCB aroclors.
Approach:
In this proposal, we will examine the immunotoxicity of PCBs and their biodegraded products using two well defined immunologic parameters as indicators of immunotoxicity. First, we will assess both non-degraded and biodegraded PCBs on their ability to modulate the murine B cell proliferative response to the mitogen, lipopolysaccaride (LPS). Second, we will investigate the ability of these same chemical mixtures to modulate in vivo the generation of an anti-sheep red blood cell (sRBC) response in mice. We have chosen several mixtures of PCBs based on their prevalence in the environment and concerns over their general toxicological impact. Further, these mixtures are targets of novel bioremediation technologies that are currently being implemented in situ. We have chosen to examine the aerobic degradation of two commercial PCB mixtures, Aroclor 1242 and 1254 by two microorganisms, Pseudomonas sp. LB400 and Alcaligenes eutrophus H850. In addition, we will couple the anaerobic reductive dechlorination of Aroclor 1260, a heavily halogenated PCB mixture, with subsequent aerobic degradation of this mixture.
Expected Results:
Three potential outcomes are possible from these studies: (i) the biodegraded product is less toxic than the parent compound; (ii) the biodegraded compound is more toxic than the parent compound; or (iii) the biodegraded compound is as toxic as the parent compound. The data sets will consist of dose-response curves for non-degraded Aroclor mixtures and biodegraded Aroclor mixtures. The trends associated with each non-degraded PCB Aroclor mixture and biodegraded PCB aroclor mixture will be compared and evaluated for three potential outcomes as listed above. For each data set, a gas chromatographic profile of the classes of compounds present in the biodegraded and nondegraded samples will be generated. If the biodegradation process results in the dechlorination of the PCB aroclor mixture, we predict a decrease of immunotoxicty since an association of increased immunotoxicity in vivo and in our in vitro proliferation assay correlates with more heavily chlorinated PCB aroclors. In this case, it would be predicted that cells exposed to these samples might exhibit normal growth rates and proliferative potential . In these cases the loss of chlorination will be analyzed in the biodegraded samples by chromatography. Second, a trend of increased or similar immunotoxicity as compared to the parent Aroclor following biodegradation may occur. The biodegradation of the Aroclor may produce co-metabolitic intermediates of PCB degradation, including chlorinated benzoates, which are more toxic than the parent compound. If this is the case, these compounds can be separated from the declorinated PCB sample and both fractions can be analyzed individually for immunotoxicity. In either case, the contribution to immunotoxicity of the dechlorination of PCB aroclors as well as the production of co-metabolites will be evaluated in this manner.
We predict that the results obtained in vivo will parallel the results ob
Publications and Presentations:
Publications have been submitted on this project: View all 14 publications for this projectJournal Articles:
Journal Articles have been submitted on this project: View all 2 journal articles for this projectSupplemental Keywords:
PCBs, PCB metabolite, mouse, immunotoxicity, biodegradation, bioremediation., RFA, Health, Scientific Discipline, PHYSICAL ASPECTS, Waste, Environmental Chemistry, Health Risk Assessment, chemical mixtures, Risk Assessments, Analytical Chemistry, Biochemistry, Physical Processes, Bioremediation, complex mixtures, ecological risk assessment, detoxification, aerobic degradation, biodegradation, exposure, PCBs, environmental mutagens, human exposure, PCB, in situ bioremediation, immune systems, bioacummulation, aroclor, bioaccumulation, human health risk, immune responseProgress and Final Reports:
2000 Progress Report2001 Progress Report
Final Report


"Showing off" my learning progress in front-end web
Layout and bootstrap
Layout with css grid and flexbox (need to set flags in the browser to enjoy this experience (best UX!!!))


test
choose game
football
basket
volipall
bessball
tenes
regpy
golf
Quantity
Enter Your Name
Image
User
game
Quantity
random


About
Projects
Skills
Contacts
GeekData
sigma.js, JS, CSS
Heat Map
D3.js
Meteorite Landing
D3.js
Crawler Game
React, SASS
Game of Life
React, SASS
Mint
JavaScript
LINQ to ES6
JS, ES6
Pet Projects
JS, C#, D3.js, Node.js...
For the last few years, I have been working on interprise web applications. Due to employers' NDAs, I'm not able to publicly display my work.
Enterprise Apps
ASP.NET MVC (C#), JS, Knockout.js, Angular...