Collection of information
The data we collect depends on the context of your interactions with us ,
the choices you make , including your privacy settings , and the products and features you use .
The data we collect can include SDK/API/JS code version , browser ,
Internet serVice provider ,IP address , platform ,times ,application indentifier , application version , application distribution channel ,
independent deice identifier ,IOS ad identifier(IDFA) , Android ad master identifler , network card (MAC) address , and international mobile device identiflcation code (IMEI) The equipment model ,
the terminal manufacturer , the terminal device operating system Version , the session start/stop time , the location of the language , the time zone and the network state ( WIFi and 50 on ) ,
the hard disk , the CPU , and the battery use , etc .
Use of personal data
When you use your account to log in to App,we will collect the basic information you fill in and the health data collected by the smart wearer,We will
story and analyze your data so as to provide you with better data presentation and health guidance.
How you do not want your personal data to be collected,you can log in with no account.
International transfers of personal data
Our business may require us to shift your personal data to countries outside the European Economic Zone,which may include China.
We will take appropriate measures to ensure that the recipients or your personal data perform the obligation of confidentiality.
If you do not want your personal data to be collected and transferred,you can choose to log in which no account.
Your rights
When you use our App,we will collect information,as described,above,to better optimize and manage software so as to provide you with better services.
For your personal data collection,you have the right to select an account to log in or to log in without account.We will collect your personal data by using the account,and we will not collect your personal data without al login.
If you think our handling of your personal data and information is against the applicable law,you can complain to the regulators.


class: center, middle # Working with Range Data ## Buffalo Chapter 9 ??? Notes for the _first_ slide! --- # Introduction -- ## Chromosomes and Coordinate Systems: -- * because chromosomes are linear strings of nucleotides, they can be represented with a coordinate system -- * the coordinate system allows us to reference particular regions of a chromosome: * _a gene_ * _an exon_ * _a transposable element_ -- * once genomic datasets are represented as genomic ranges, a series of operations, particularly those involving overlap and proximity, can be carried out --- # Components of a Genomic Range -- ## Three pieces of information are necessary to specify a genomic region: -- * **Chromosome (or scaffold/contig) name**: naming conventions can vary (_e.g.,_ chr4, 4, scaffold_627) -- * **Range**: the start and end site of a genomic region (_e.g.,_ 123,654,834 to 123,654,985) -- * **Strand**: DNA is double-stranded and features can be on the forward (positive) or reverse (negative) strand. Features such as proteins can be strand-specific. -- ## Important Note: Ranges are always tied to a particular version of a genome --- ## An example of genomic ranges: --
--- ## Flavors of range systems: -- * 0-based systems: half-closed, half-open intervals -- * Range width = end - start -- * 1-based systems: closed intervals -- * Range width = end - start + 1 --
--- ## The Buffalo tutorials on genomic ranges use packages from the Bioconductor open source software project: * IRanges * GenomicRanges -- ### To Install Bioconductor's Primary Packages in R: ``` > source("http://bioconductor.org/biocLite.R") > biocLite() ``` -- ### GenomicRanges can be installed with: ``` > biocLite("GenomicRanges") ``` -- ### Bioconductor packages have great documentation:
--- Let's begin working with ranges in the IRanges program which was installed as a dependency of GenomicRanges: ``` > library(IRanges) ``` -- Ranges are created as "IRange Objects" by specifying start and end sites: ``` > rng <- IRanges(start=4, end=13) > rng IRanges of length 1 start end width [1] 4 13 10 ``` -- Is this 1-based or 0-based? -- Now try creating a range by specifying start site and width: ``` rng2 <- IRanges(start=4, width=3) rng2 ``` --- Ranges can also be created using vector arguments: ``` > x <- IRanges(start=c(4, 7, 2, 20), end=c(13, 7, 5, 23)) > x ``` -- And we can give these ranges names: ``` > names(x) <- letters[1:4] > x ``` -- Note that the ranges we create are a special object with class IRanges: ``` > class(x) ``` -- Components of this object can be accessed with start(x), end(x), width(x) -- This can by handy when we want to increment one of these components: ``` > end(x) <- end(x) + 4 > x ``` --- The `range()` function can also be used to inspect the entire length of all ranges in an IRanges object: ``` > range(x) ``` -- We can also take subsets of ranges in an IRanges object using numeric, logical, and character indices -- For example, try the following: ``` > x[2:3] > start(x) < 5 > x[start(x) < 5] > x[width(x) > 8] ``` -- Ranges can also be merged, just as we've done with vectors using the `c()` command: ``` > a <- IRanges(start=7, width=4) > b <- IRanges(start=2, end=5) > c <- c(a, b) > c ``` --- ### Basic Range Operations: -- IRanges objects can be grown or shrunk using arithmetic operations such as +, -, and * (division is not supported since it makes little sense with ranges) -- For example, try: ``` > x <- IRanges(start=c(40, 80), end=c(67, 114)) > x + 4L > x - 10L ``` -- What's going on here? --
--- Sometimes, rather than growing or shrinking ranges, we want to restrict them within particular bounds -- In this situation, the function `restrict()` comes in handy: ``` > y <- IRanges(start=c(4, 6, 10, 12), width=13) > y > restrict(y, 5, 10) ``` -- What's happening here? --
--- Perhaps you would like to create entirely new ranges based on their relative position to ranges you already have -- When might this be handy? -- For this application, you would use the `flank()` command: ``` > flank(x, width=7) > flank(x, width=7, start=FALSE) > promoters <- flank(x, width=20) ``` -- And here's a visual representation of these new ranges:
--- We may also be interested in collapsing several reads into "super reads" that show the coverage extent of our ranges -- For example, perhaps we have mapped sequence reads to a reference and we would like to see the proportion of genomic coverage -- Let's try a simple example: ``` > set.seed(0) # set the random number generator seed > alns <- IRanges(start=sample(seq_len(50), 20), width=5) > head(alns, 10) ``` -- and now let's collapse these into super reads using the `reduce()` command: ``` > reduce(alns) ``` -- Here's a visual representation of what `reduce()` is doing... ---
--- Rather than extent of coverage, we may be interested in gaps between our ranges -- Here, the `gaps()` command will come in handy: ``` > gaps(alns) ``` -- Which produces new ranges that span gaps in an indicated IRanges object: --
--- IRange ranges can also be treated as a set of consecutive integers, so `IRange(start=4, end=7)` would be the integers 4,5,6,7 -- Given this property, we can use various R commands on our IRange objects -- Create the following IRange objects: ``` > a <- IRanges(start=4, end=13) > b <- IRanges(start=12, end=17) ``` -- and see if you can understand how the following R commands can be applied to these objects: `setdiff()`, `union()`, `intersect()` --
--- ### Finding Overlapping Ranges: -- * Up until now we have been manipulating ranges and creating new ranges based on relationships with existing ranges -- * In many genomic applications, we may need to explicitly map overlaps between subject and query sets of ranges -- * There are many ways to assess overlap between a subject and query and it is important to be aware of the details of any given approach -- Let's create subject and query IRange objects and assess overlap with the `findOverlaps()` function: ``` > qry <- IRanges(start=c(1, 26, 19, 11, 21, 7), end=c(16, 30, 19, 15, 24, 8), names=letters[1:6]) > sbj <- IRanges(start=c(1, 19, 10), end=c(5, 29, 16), names=letters[24:26]) ``` -- Inspect the objects we've just created --- Visually, these objects look like this:
-- If we use the `findOverlaps()` function with these, we create an object of class "hits": ``` > hts <- findOverlaps(qry, sbj) ``` -- Inspect `hts` and see if you can understand its structure --- Essentially, `hts` shows a mapping of query (`qry`) to subject (`sbj`):
-- If we want to see the names of each of these hits, we can access them in this way: ``` > names(qry)[queryHits(hts)] > names(sbj)[subjectHits(hts)] ``` -- Based on Figure 9-11, how is `findOverlaps()` assessing overlap? -- Let's tweak how `findOverlaps()` identifies overlap with the `type` argument: ``` hts_within <- findOverlaps(qry, sbj, type="within") ``` -- What has changed? --- We can also limit our hits to a single match between subject and query using the argument `select` -- Try the following options for `select` and see if you can understand how `findOverlaps()` has changed: ``` > findOverlaps(qry, sbj, select="first") > findOverlaps(qry, sbj, select="last") > findOverlaps(qry, sbj, select="arbitrary") ``` --- There is more we can do with the `hits` object as well -- Try the following functions and see if you can understand what each is doing: ``` > as.matrix(hts) > countQueryHits(hts) > setNames(countQueryHits(hts), names(qry)) > countSubjectHits(hts) ``` --
--- Additional overlap functions can also be applied to ranges. For example: ``` > countOverlaps(qry, sbj) > subsetByOverlaps(qry, sbj) ``` -- What are these doing? --- ### Finding Nearest Ranges and Calculating Distances: -- We can also use range functions to find subject ranges close to our query ranges -- For example, try the following: ``` > qry <- IRanges(start=6, end=13, name='query') > sbj <- IRanges(start=c(2, 4, 18, 19), end=c(4, 7, 21, 24), names=1:4) > nearest(qry, sbj) > precede(qry, sbj) > follow(qry, sbj) ``` -- We can also directly calculate the distance between query and subject ranges: ``` > qry <- IRanges(sample(seq_len(1000), 5), width=10) > sbj <- IRanges(sample(seq_len(1000), 5), width=10) > distanceToNearest(qry, sbj) > distance(qry, sbj) ``` --- ### Storing Genomic Ranges with GenomicRanges: GRanges are very similar to IRanges but include information on chromosome, strand, and, optionally, metadata -- Creation of GRanges is very similar to IRanges: ``` > library(GenomicRanges) > gr <- GRanges(seqname=c("chr1", "chr1", "chr2", "chr3"), ranges=IRanges(start=5:8, width=10), strand=c("+", "-", "-", "+")) > gr ``` -- And here with an example of metadata: ``` > gr <- GRanges(seqname=c("chr1", "chr1", "chr2", "chr3"), ranges=IRanges(start=5:8, width=10), strand=c("+", "-", "-", "+"), gc=round(runif(4), 3)) > gr ``` -- Essentially any type of data can be stored in metadata columns which is what makes GRanges so powerful --- We can also specify the lengths of each chromosome which are necessary for calculating coverage, gaps, etc... ``` > seqlens <- c(chr1=152, chr2=432, chr3=903) > gr <- GRanges(seqname=c("chr1", "chr1", "chr2", "chr3"), ranges=IRanges(start=5:8, width=10), strand=c("+", "-", "-", "+"), gc=round(runif(4), 3), seqlengths=seqlens) > gr ``` -- Like IRanges objects, we can use accessor functions to pull out specific types of data from Granges: ``` > start(gr) > end(gr) > width(gr) > seqnames(gr) > strand(gr) ``` --- Names can also be given to individual elements within a GRanges object: ``` > names(gr) <- letters[1:length(gr)] ``` -- And GRanges also supports subsetting and additional R functions: ``` > start(gr) > 7 > gr[start(gr) > 7] > table(seqnames(gr)) > gr[seqnames(gr) == "chr1"] ``` -- Finally, the `mcols()` function can be used to access metadata columns: ``` > mcols(gr) > mcols(gr)$gc ``` -- and can be combined with subsetting and other functions for advanced queries of data: ``` > mcols(gr[seqnames(gr) == "chr1"])$gc > mean(mcols(gr[seqnames(gr) == "chr1"])$gc) ``` --- ### Grouping Data with GRangesList: -- Very similar to the lists we learned about previously in R, GRanges has a data structure called `GRangesList` -- These can be built manually: ``` > gr1 <- GRanges(c("chr1", "chr2"), IRanges(start=c(32, 95), width=c(24, 123))) > gr2 <- GRanges(c("chr8", "chr2"), IRanges(start=c(27, 12), width=c(42, 34))) > grl <- GRangesList(gr1, gr2) ``` -- And behave very similarly to typical lists in R: ``` > unlist(grl) > doubled_grl <- c(grl, grl) ``` --- While above we've created GRangesLists manually, they are often produced by splitting GRanges: ``` > chrs <- c("chr3", "chr1", "chr2", "chr2", "chr3", "chr1") > gr <- GRanges(chrs, IRanges(sample(1:100, 6, replace=TRUE), width=sample(3:30, 6, replace=TRUE))) > gr > gr_split <- split(gr, seqnames(gr)) > gr_split[[1]] > gr_split[[2]] ``` -- Splitting GRanges into GRangesLists facilitates easier access to subsets of GRanges -- Splitting is also useful because we can then use `lapply` and `sapply` across individual elements of the list: ``` > lapply(gr_split, function(x) order(width(x))) > sapply(gr_split, function(x) min(start(x))) > sapply(gr_split, length) ``` --- ### Working with Annotation Data: GenomicFeatures and rtracklayer: -- * Now let's work with GRanges in the context of real data while learning a few new Bioconductor packages -- * `GenomicFeatures` is a package for creating and working with transcript-based annotations in the form of `TranscriptDb` objects. -- * `rtracklayer` is designed for importing and exporting annotation data into a variety of different formats -- First, let's install `GenomicFeatures`: ``` > library(BiocInstaller) > biocLite("GenomicFeatures") ``` -- And then, let's install an annotation package for the house mouse (_Mus musculus_): ``` > biocLite("TxDb.Mmusculus.UCSC.mm10.ensGene") > library(TxDb.Mmusculus.UCSC.mm10.ensGene) > txdb <- TxDb.Mmusculus.UCSC.mm10.ensGene ``` --- We've just built an SQLite database for _Mus musculus_ transcripts within R -- Various types of annotations can be extracted using accessor functions: ``` > genes(txdb) > transcripts(txdb) > exons(txdb) > promoters(txdb) ``` -- Inspect a few of these using `head(genes(txdb))` for example...what type of objects are produced? -- We can group these GRanges objects into GRangesLists using a number of different functions such as `transcriptsBy()`, `exonsBy()`, `cdsBy()`, `intronsBy()`, `fiveUTRsByTranscript()`, and `threeUTRsByTranscript()` -- For example: ``` > mm_exons_by_gn <- exonsBy(txdb, by="gene") ``` --- We can also control what portions of a genome are queried by limiting to a particular chromosome: ``` > seqlevels(txdb, force=TRUE) <- "chr1" > chr1_exons <- exonsBy(txdb, by="gene") > txdb <- restoreSeqlevels(txdb) # restore txdb so it queries all sequences ``` -- or by searching within a particular interval by using the "x"ByOverlaps family of functions: ``` > candidate_region <- GRanges("chr8", IRanges(123250562, 123567264)) > transcriptsByOverlaps(txdb, candidate_region) ``` -- While the `GenomicsFeatures` package and `transcriptDb` objects are straight-forward, convenient and consistent across genome versions and species, this comes at a cost to flexibility -- The `rtracklayer` package is not quite as user-friendly, but is more flexible --- Data can be imported and exported from/to a variety of formats using `rtracklayer` (_e.g.,_, GTF/GFF, BED, BED Graph, etc...) -- Imported data are converted into `GRanges` objects and missling data and metadata columns are automatically dealt with -- As an example, let's try importing a file from the GitHub repository of the Buffalo book: ``` > library(rtracklayer) > mm_gtf <- import('Mus_musculus.GRCm38.75_chr1.gtf.gz') > colnames(mcols(mm_gtf)) # metadata columns read in ``` -- `rtracklayer` has automatically detected the imported file type and has brought this in as a `GRanges` object --- We can also use `rtracklayer` to export subsets of the this data file to files of any format we choose: ``` > set.seed(0) > pseudogene_i <- which(mm_gtf$gene_biotype == "pseudogene" & mm_gtf$type == "gene") > pseudogene_sample <- sample(pseudogene_i, 5) > export(mm_gtf[pseudogene_sample], con="five_random_pseudogene.gtf", format="GTF") ``` --- ### Now let's try using these packages and the commands we've learned in an example: -- Let's first import a file with variants (SNPs, indels, etc...) from chr1 of _Mus musculus_: ``` > dbsnp137 <- import("mm10_snp137_chr1_trunc.bed.gz") ``` -- We want to find all variants within exons on this mouse chromosome. Let's first collapse all overlapping exons in the mouse `TranscriptDb` object we created earlier and create an object with only exons from chr1: ``` > collapsed_exons <- reduce(exons(txdb), ignore.strand=TRUE) > chr1_collapsed_exons <- collapsed_exons[seqnames(collapsed_exons) == "chr1"] ``` -- Before extracting variants in exons, let's first inspect our variant file: ``` > summary(width(dbsnp137)) ``` --- If a variant has a width of 0, we cannot find its overlap with exon ranges, so we must adjust its width to do this: ``` > dbsnp137_resized <- dbsnp137 > zw_i <- width(dbsnp137_resized) == 0 > dbsnp137_resized[zw_i] <- resize(dbsnp137_resized[zw_i], width=1) ``` -- We can now pull out those variants that overlap exons on chromosome 1 by creating a `hits` object: ``` > hits <- findOverlaps(dbsnp137_resized, chr1_collapsed_exons, ignore.strand=TRUE) ``` -- and determine the number of variants and the proportion of variants that are exonic: ``` > length(unique(queryHits(hits))) > length(unique(queryHits(hits)))/length(dbsnp137_resized) ``` --- We can also use the `countOverlaps()` function to find the number of variants per exon (note we have to reverse the order of the query since we're finding values per exon now) ``` > var_counts <- countOverlaps(chr1_collapsed_exons, dbsnp137_resized, ignore.strand=TRUE) ``` -- and we can append this to our `GRanges` object that includes exons: ``` > chr1_collapsed_exons$num_vars <- var_counts ```


janus¶
driver¶
This is the qmmm driver module
-
janus.driver.
run_janus
(filename='input.json')¶ Drives the janus program. Creates an instance of the Initializer class and feeds wrappers to either
run_simulation()
orrun_single_point()
Parameters: filename (str) – Filename from which to read input parameters
-
janus.driver.
run_simulation
(md_sim_wrapper, qmmm_wrapper)¶ Drives QM/MM with MD time step integration
Parameters:
system¶
-
class
janus.system.
System
(qm_indices, qm_residues, run_ID, partition_ID='qm')¶ Bases:
object
A class that stores system information. Holds information such as energy, forces, and positions for a QM/MM partition. Stores qmmm and aqmmm information as well.
Parameters: - indices (qm) – indices of the atoms of the QM region
- run_ID (int) – the current step of the MD simulation
- partition_ID – An identifier for the specfic partition in aqmmm computations, default is ‘qm’
-
compute_scale_factor_g
(mm, link)¶ Computes scale factor g for link atom, RC, and RCD schemes. The equation used to compute g is:
rac{R_{qm} + R_{link}}{R_{qm} + R_{mm}}
where R is the pyykko covalent radius of an atom.
- qm : str
- element symbol of the QM atom involved in broken bond
- mm : str
- element symbol of the MM atom involved in broken bond
- link : str
- element symbol for link atom
- float
- g, the scaling factor
>>> compute_scale_factor_g('C', 'C', 'H')
-
class
janus.system.
Buffer
(ID)¶ Bases:
object
A class to store information for buffer groups from aqmmm computations. This includes the atom indicies contained in the buffer group, the switching function, COM coordinates, etc.
Parameters: ID – the identifer for the buffer group
Initializer¶
-
class
janus.initializer.
Initializer
(parameters, as_file=True)¶ Bases:
object
Class that initializes the initial parameters and necessary wrapppers.
Parameters: - paramaters (str) – filename of a json input file; if as_file is False, param is a dict
- as_file – param is a file if True, dict if False
-
get_wrappers
()¶ Determines what type of wrapper object to instantiate based on input parameters
-
initialize_wrappers
()¶ Instantiates wrapper objects based on input parameters. Create instances of appropriate wrappers for low and high level computations, QM/MM or adaptive QM/MM computations, as well as MD simulations.
Returns:
-
load_param
(fname)¶ Converts a json file into a dictionary
Parameters: fname (str) – name of json file Returns: parameters contained in filename Return type: dict
-
set_attributes
(dictionary, obj)¶ Sets values in the dicionary to be an attribute of the object given. The key of the dictionary will be set as an attribute of the object given.
Parameters: - dictionary (dict) – Dictionary with relevant parameters
- obj (obj) – Object to have attributes set to.
Returns: Return type: None
Examples
>>> set_attributes({'aqmmm' : False}, self)
This sets self.aqmmm to be False.


Ind vs England
Selected Player(
0
)
Wicket Keeper
Batsman
All Rounder
Bowler
Choose Combination
Generate Team


|
Contiki 2.5
|
Defines | |
| #define | UIP_LINK_MTU 1280 |
| The maximum transmission unit at the IP Layer. | |
| #define | UIP_CONF_IPV6 0 |
| Do we use IPv6 or not (default: no) | |
| #define | UIP_CONF_IPV6_QUEUE_PKT 0 |
| Do we do per neighbor queuing during address resolution (default: no) | |
| #define | UIP_CONF_IPV6_CHECKS 1 |
| Do we do IPv6 consistency checks (highly recommended, default: yes) | |
| #define | UIP_CONF_IPV6_REASSEMBLY 0 |
| Do we do IPv6 fragmentation (default: no) | |
| #define | UIP_CONF_NETIF_MAX_ADDRESSES 3 |
| Default number of IPv6 addresses associated to the node's interface. | |
| #define | UIP_CONF_ND6_MAX_PREFIXES 3 |
| Default number of IPv6 prefixes associated to the node's interface. | |
| #define | UIP_CONF_ND6_MAX_NEIGHBORS 4 |
| Default number of neighbors that can be stored in the neighbor cache. | |
| #define | UIP_CONF_ND6_MAX_DEFROUTERS 2 |
| Minimum number of default routers. |


Your company qualifies for a tax credit due to increased spending on research activities. We need you to fill in
the following information in order to file the R&D tax credit along with your Federal Tax Return.
To-Do
Category
Spending
Total R&D Wages Paid
Total Cost of R&D Supplies
Total Rental/Lease Cost of Computers
Status
Action
Person
Status
1.
Fill out 6567
Mo
2.
Spending Information
You
3.
File Federal Tax Return
Mo
4.
Send to IRS
Mo
Ready to Leave?
Select "Logout" below if you are ready to end your current session.


Sync is in progress. Running services will be listed when it finishes
There are not {a service['name'] | removeSpecialCharacters a} services running. Create one
Are you sure you want to remove the service instance {a running_service['name'] a}


Server:
ProjectID:
DossierID:
If you have already logged in,the dossier will show automatically.
Otherwise, you can click
to log in. MicroStrategy 2021+ is required for this to work.


{{member.bio}}
{% for member in site.data.members %} {% if member.roles contains 'member' %} {% endif %} {% endfor %}
{% for member in site.data.members %} {% if member.roles contains 'former' %} {% endif %} {% endfor %}


Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Donec velit neque, auctor sit amet aliquam vel, ullamcorper sit amet ligula. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque in ipsum id orci porta dapibus. Vivamus magna justo, lacinia eget consectetur sed, convallis at tellus. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Donec velit neque, auctor sit amet aliquam vel, ullamcorper sit amet ligula.
Handles the /news url
Goes through the pipeline
hits the mvc controller or a custom controller
Finds the matching content for /news
Content has a content type that defines its data
It has a template that defines its presentation
Based on the schema a template is loaded
Template is rendered with Razor
Model refers to the found content
There are API’s to query media, members and content in the cache
A template can also contain: Partial Views, Macros, Forms controller by a surface controller
Template is rendered with Razor
Model refers to the found content
There are API’s to query media, members and content in the cache
Template is rendered with Razor
Funky javascript
Make things pretty and UNICORNY
And use client dependency to optimise


The Busy Blue Jay: True Bird Stories from My Notebooks
by Olive Thorne Miller
The Busy Blue Jay, Chapter 2
Additional Information
- Year Published: 1903
- Language: English
- Country of Origin: United States of America
- Source: Miller, O.T. (1903). The Busy Blue Jay: True Bird Stories from My Notebooks. New York: Houghton, Mifflin & Co.
-
Readability:
- Flesch–Kincaid Level: 6.0
- Word Count: 736
- Genre: Essay
- ✎ Cite This
Downloads
Jakie had decided opinions about people who came into the room to see me, or to see the birds. At some persons he would squawk every moment.  Once when a lady came in with a baby, he fixed his eyes on that infant with a savage look as if he would like to peck it, and jumped back and forth in his cage, panting, but perfectly quiet.
Jakie was very devoted to me. He always greeted me with a low, sweet chatter, with wings quivering, and if he were out of the cage he would come on the back of my chair and touch my cheek or lips very gently with his beak, or offer me a bit of food if he had any; and to me alone, when no one else was near, he sang a low, exquisite song. I afterwards heard a similar song sung by a wild blue jay to his mate while she was sitting, and so I knew that my dear little captive had given me his sweetest—his love song.
 He would keep up this funny performance as long as anybody would stand before him and pretend to dance, too.
My jay was fond of a sensation. One of his dearest bits of fun was to drive the birds into a panic. This he did by flying furiously around the room, feathers rustling, and squawking as loud as he could. He usually managed to fly just over the head of each bird, and as he came like a catapult, every one flew before him, so that in a minute the room was full of birds flying madly about trying to get out of his way. This gave him great pleasure.
Wild blue jays, too, like to stir up their neighbors. A friend told me of a small party of blue jays that she saw playing this kind of a joke on a flock of birds of several kinds, robins, catbirds, thrashers, and others. These birds were gathering the cherries on the top branches of a big cherry tree. The jays sat quietly on another tree till the cherry eaters were very busy eating. Then suddenly the mischievous blue rogues would all rise together and fly at them, as my pet did at the birds in the room. It had the same effect on the wild birds; they all flew in a panic. Then the joking jays would return to their tree and wait till their victims forgot their fear and came straggling back to the cherries, when they repeated the fun.
Once a grasshopper got into the Bird Room, probably brought in clinging to some one’s dress in the way grasshoppers do. Jakie was in his cage, but he noticed the stranger instantly, and I opened the door for him. He went at once to look at the grasshopper, and when it hopped he was so startled that he hopped, too. Then he picked the insect up, but he did not know what to do with it, so he dropped it again. Again the grasshopper jumped directly up, and again the jay did the same. This they did over and over, till every one was tired laughing at them. It looked as if they were trying to see who could jump the higher.
There was another bird in the room, however, who knew what grasshoppers were good for. He was an orchard oriole, and after looking on for a while, he came down and carried off the hopper to eat. The jay did not like to lose his plaything; he ran after the thief, and stood on the floor giving low cries and looking on while the oriole on a chair was eating the dead grasshopper. When the oriole happened to drop it, Jakie—who had got a new idea of what to do with grasshoppers—snatched it up and carried it under a chair and finished it.
I could tell many more stories about my bird, but I have told them before in one of my “grown-up” books, so I will not repeat them here.


It seems as though you have not calculated your BMR yet. Click on the button below to calculate it now! CrystalCalculate


Hi, my name is Garfield Grant, I was born on the island of Jamaica in the year 1991. I served 8 years in the United States Military where I learned alot of cool things while traveling and establishing a network of awesome and amazing people. Some of my hobbies include swimmming, learning, getting to know people aka networking and listening to music. Some of my favourite beverages are coconut water, coffee, and just plain old water.By day I'm an Integration and Reporting Consultant, and during the night I enjoy doing things like spending time with family, writing code, sleeping and meditating and relfecting on my day.
Education Experience
- Code Fellow | 2021 Python Software Engineer
- University of Maryland Global Campus
Cybersecurity Management and Policy Bsc. | 2020
Work Experience
- Hybridge Solutions Integration Software Consulting | Jan 2021
- Workforce Insight Integration Software Consultant | July 2020 - Jan 2021
- United States Army Nov 2012 - Nov 2020
Some of my goals while attending Code Fellows include:
- Become a good python developer.
- Understand other languages sufficirntly that way I can apply them where necessary.
- Network and create a strong professional relationship with other Engineers.
Top Ten Favorite People Dead or Alive.
- H.I.M Halie Selassie
- Malcom X
- Maya Angelou
- Marcus Garvey
- Bob Marley
- James Baldwin
- Usain Bolt
- Louis Farrakhan
- Sean Carter
- Nikki Giovanni


It's been good Seattle, but I'm headed to Portland! 🚲🚲🚲
7/16/2016, 4:58:46 AM
Favs: 6
Retweets: 0
link--- layout: tweet ---
It's been good Seattle, but I'm headed to Portland! 🚲🚲🚲
7/16/2016, 4:58:46 AM
Favs: 6
Retweets: 0
linkDay one complete in 6:20. Not bad given I missed biking Jan-March this year from broken shoulder. Now rest and 🍻!
7/16/2016, 1:23:28 PM
Favs: 2
Retweets: 0
linkAnd finished! 6:15 on 105 miles. Better than I expected. Last bit is easiest part of day-2. So much fun rolling in feeling strong! 🚲💨
7/17/2016, 1:12:42 PM
Favs: 4
Retweets: 0
link... and for the stats minded among you here's my two @strava rides https://www.strava.com/activities/645146539 https://www.strava.com/activities/645146544
7/18/2016, 10:35:34 AM
Favs: 2
Retweets: 0
link


This example demonstrates how to generate an input/output block (e.g. in form of an FMU - Functional Mock-up Unit) from various Rotational components. The goal is to export such an input/output block from Modelica and import it in another modeling environment. The essential issue is that before exporting it must be known in which way the component is utilized in the target environment. Depending on the target usage, different flange variables need to be in the interface with either input or output causality. Note, this example model can be used to test the FMU export/import of a Modelica tool. Just export the components marked in the icons as "toFMU" as FMUs and import them back. The models should then still work and give the same results as a pure Modelica model.
Connecting two inertias
The upper part (DirectInertia, InverseInertia) demonstrates how to
export two inertias and connect them together in a target system.
This requires that one of the inertias (here: DirectInertia) is
defined to have states and the angle, angular velocity and angular
acceleration are provided in the interface. The other mass (here:
InverseInertia) is moved according to the provided input angle,
angular velocity and angular acceleration.
Connecting a force element that needs angles and angular
velocities
The middle part (SpringDamper) demonstrates how to export a force
element that needs both angles and angular velocities for its force
law and connect this force law in a target system between two
inertias.
Connecting a force element that needs only
angles
The lower part (Spring) demonstrates how to export a force element
that needs only angles for its force law and connect this force law
in a target system between two inertias.


Contributing to Open Source Part I: The Easy Way
67.098 Comments
Si mon
3 years ago
so cool to watch a video where someone gets straight into it, doesn't waffle on for 1-2 minutes about nothing and explains the process clearly. good job!
so cool to watch a video where someone gets straight into it, doesn't waffle on for 1-2 minutes about nothing and explains the process clearly. good job!
Si mon
3 years ago
so cool to watch a video where someone gets straight into it, doesn't waffle on for 1-2 minutes about nothing and explains the process clearly. good job!
so cool to watch a video where someone gets straight into it, doesn't waffle on for 1-2 minutes about nothing and explains the process clearly. good job!
Nick Haras
5 years ago
"use your powers for good" haha thank you for the video. Wow this video was super helpful, clear, and concise. Thank you very much.
"use your powers for good" haha thank you for the video. Wow this video was super helpful, clear, and concise. Thank you very much.
Andreas Samaris
10 minites ago
This video didnt help. I see it was uploaded 3 years ago but I wonder if that would to do it.
This video didnt help. I see it was uploaded 3 years ago but I wonder if that would to do it.
Neto Daniel Zinga
1 year ago
Your video helped me try to make my first contribution! Thank you so much!
Your video helped me try to make my first contribution! Thank you so much!
Lydia Freeman
13 minites ago
Y Una Vez Puesto El Botón Como Hago Par Vincularlo O Enlazarlo A Mi Pagina De Facebook
Y Una Vez Puesto El Botón Como Hago Par Vincularlo O Enlazarlo A Mi Pagina De Facebook
Published on May 30, 2019
If you want to build bigger rear delts, the first thing you need to do is stop doing reverse dumbbell flies with light weights. In this video, I’m going to show you the fastest way to bigger rear delts by properly overloading the muscles with a better exercise alternative. As a matter of fact, we are


Providing Formative Feedback on a Wizard
If you have appropriate permissions to act as a reviewer, you may review and provide formative feedback on the work of any
site participant in any wizard in the site. Each participant's work is displayed in read-only mode.
To provide feedback, you fill out a form that is linked to the wizard as a whole or to a particular page and give your completed
form a unique title. This completed form is then available to the site participant. Subsequently, you may fill out the same
form any number of times (with a different title each time) to provide feedback on changes the participant may have made.
You may review and provide feedback at any time up until the participant submits the wizard or the wizard page for summative
evaluation.
To review and provide feedback on a wizard, access the Wizards tool and follow these steps:
- If the Wizards home page is not displayed, click the Reset button.
- Use the dropdown list to select the name of the person whose wizard you want to review.
- Click Go. Sakai displays a list of wizards for the user you specified.
- Find the wizard you want to review and click its name. Sakai displays the introductory page of that wizard.
- Review the introductory page and then click Continue. Sakai displays the first page of the wizard. If this is not the page
you want to work with, click Continue until you reach the appropriate page.
- To review an attached item on any page, click its name.
- To enter feedback, click the Add Feedback link in the "Feedback" section at the bottom of the page. Sakai displays a screen
containing a feedback form.
- Enter information in the fields, as appropriate.
Caution: The Access section of the screen allows you to make your feedback public to people other than the participant whose work
you are reviewing. As a general rule, we advise against making feedback public in any way. To keep your feedback between you
and the participant, do not click either radio button in this section.
- To add your feedback, click Add. Sakai displays the wizard page again. The title of your feedback is shown in the Feedback
section of the screen.
- Choose from among these options:
- To review other pages in this participant's wizard, click Continue.
- To return to the Wizards home page, click Return to Wizards.
- If you have reached the last page of the wizard, click Finish to return to the Wizards home page.


{%- include_relative _includes/resume/about.html -%}
{%- include_relative _includes/resume/skills.html -%}
{%- include_relative _includes/resume/experience.html -%}
{%- include_relative _includes/resume/education.html -%}


|
| | Vec2 (double x, double y) |
| |
| double | length () |
| |
| double | sqrLength () |
| |
| Vec2 | add (Vec2 v) |
| |
| Vec2 | add (double x, double y) |
| |
| Vec2 | addld (double distance, double direction) |
| |
| Vec2 | sub (Vec2 v) |
| |
| Vec2 | sub (double x, double y) |
| |
| double | dot (Vec2 v) |
| |
| double | dot (double x, double y) |
| |
| Vec2 | mul (double f) |
| |
| double | cross (Vec2 v) |
| |
| Vec2 | lerp (Vec2 v, double ammount) |
| |
| double | directionTo (Vec2 v) |
| |
| double | directionTo (double x, double y) |
| |
| Vec2 | rotate (double angle) |
| |
| Vec2 | rotateAround (Vec2 origin, double angle) |
| |
| double | distanceTo (Vec2 v) |
| |
| double | distanceTo (double x, double y) |
| |
| double | sqrDistanceTo (Vec2 v) |
| |
| double | sqrDistanceTo (double x, double y) |
| |
| double | distanceTo (Vec2 v, Metric metric) |
| |
| double | distanceTo (double x, double y, Metric metric) |
| |
| Vec2 | normalize () |
| |
| Vec2 | negate () |
| |
| Vec2 | toLength (double length) |
| |
| boolean | insideTriangle (Vec2 p1, Vec2 p2, Vec2 p3) |
| |
| Vec3 | coordsInTriangle (Vec2 p1, Vec2 p2, Vec2 p3) |
| |
| Vec2 | normal () |
| |
| boolean | isZero () |
| |
| boolean | equals (Object o) |
| |
| boolean | equals (Vec2 v) |
| |
| boolean | equals (double x, double y) |
| |
| String | toString () |
| |
|
| static double | ldx (double length, double direction) |
| |
| static double | ldx (double distance, double direction, double originX) |
| |
| static double | ldy (double length, double direction) |
| |
| static double | ldy (double distance, double direction, double originY) |
| |
| static Vec2 | ld (double length, double direction) |
| |
| static Vec2 | ld (double distance, double direction, double originX, double originY) |
| |
| static Vec2 | randUnit () |
| |
| static Vec2 | randUnit (RandomGenerator rand) |
| |
| static Vec2 | onEllipse (double r1, double r2, double angle) |
| |
| static Vec2 | onEllipse (double r1, double r2, double angle, Vec2 center) |
| |
|
| final double | x |
| |
| final double | y |
| |
Immutable representation of a 2D vector.
Definition at line 4 of file Vec2.java.
◆ Vec2()
| cz.zdepav.school.texiscript.utils.Vec2.Vec2 |
( |
double |
x, |
|
|
double |
y |
|
) |
| |
Constructs a vector from two coordinates.
Definition at line 19 of file Vec2.java.
◆ add() [1/2]
| Vec2 cz.zdepav.school.texiscript.utils.Vec2.add |
( |
double |
x, |
|
|
double |
y |
|
) |
| |
Adds another vector to this one and returns the result.
Definition at line 40 of file Vec2.java.
◆ add() [2/2]
| Vec2 cz.zdepav.school.texiscript.utils.Vec2.add |
( |
Vec2 |
v | ) |
|
Adds another vector to this one and returns the result.
Definition at line 35 of file Vec2.java.
◆ addld()
| Vec2 cz.zdepav.school.texiscript.utils.Vec2.addld |
( |
double |
distance, |
|
|
double |
direction |
|
) |
| |
Adds another vector to this one and returns the result.
- Parameters
-
| distance | other vector's length |
| direction | other vector's direction in radians |
- Returns
- Resulting vector.
Definition at line 50 of file Vec2.java.
◆ coordsInTriangle()
| Vec3 cz.zdepav.school.texiscript.utils.Vec2.coordsInTriangle |
( |
Vec2 |
p1, |
|
|
Vec2 |
p2, |
|
|
Vec2 |
p3 |
|
) |
| |
Computes barycentric coordinates of this point within a given triangle.
- Parameters
-
| p1 | triangle's first vertex |
| p2 | triangle's second vertex |
| p3 | triangle's third vertex |
- Returns
- Barycentric coordinates of this point within the given triangle.
Definition at line 203 of file Vec2.java.
◆ cross()
| double cz.zdepav.school.texiscript.utils.Vec2.cross |
( |
Vec2 |
v | ) |
|
Computes the cross product with another vector.
Definition at line 80 of file Vec2.java.
◆ directionTo() [1/2]
| double cz.zdepav.school.texiscript.utils.Vec2.directionTo |
( |
double |
x, |
|
|
double |
y |
|
) |
| |
Computes angle from this point to another one.
Definition at line 106 of file Vec2.java.
◆ directionTo() [2/2]
| double cz.zdepav.school.texiscript.utils.Vec2.directionTo |
( |
Vec2 |
v | ) |
|
Computes angle from this point to another one.
Definition at line 101 of file Vec2.java.
◆ distanceTo() [1/4]
| double cz.zdepav.school.texiscript.utils.Vec2.distanceTo |
( |
double |
x, |
|
|
double |
y |
|
) |
| |
Computes distance from this point to another one.
Definition at line 139 of file Vec2.java.
◆ distanceTo() [2/4]
| double cz.zdepav.school.texiscript.utils.Vec2.distanceTo |
( |
double |
x, |
|
|
double |
y, |
|
|
Metric |
metric |
|
) |
| |
Computes distance from this point to another one in a given metric.
Definition at line 163 of file Vec2.java.
◆ distanceTo() [3/4]
| double cz.zdepav.school.texiscript.utils.Vec2.distanceTo |
( |
Vec2 |
v | ) |
|
Computes distance from this point to another one.
Definition at line 133 of file Vec2.java.
◆ distanceTo() [4/4]
| double cz.zdepav.school.texiscript.utils.Vec2.distanceTo |
( |
Vec2 |
v, |
|
|
Metric |
metric |
|
) |
| |
Computes distance from this point to another one in a given metric.
Definition at line 157 of file Vec2.java.
◆ dot() [1/2]
| double cz.zdepav.school.texiscript.utils.Vec2.dot |
( |
double |
x, |
|
|
double |
y |
|
) |
| |
Computes the dot product with another vector.
Definition at line 70 of file Vec2.java.
◆ dot() [2/2]
| double cz.zdepav.school.texiscript.utils.Vec2.dot |
( |
Vec2 |
v | ) |
|
Computes the dot product with another vector.
Definition at line 65 of file Vec2.java.
◆ equals() [1/3]
| boolean cz.zdepav.school.texiscript.utils.Vec2.equals |
( |
double |
x, |
|
|
double |
y |
|
) |
| |
Compares this vector with another one.
Definition at line 243 of file Vec2.java.
◆ equals() [2/3]
| boolean cz.zdepav.school.texiscript.utils.Vec2.equals |
( |
Object |
o | ) |
|
◆ equals() [3/3]
| boolean cz.zdepav.school.texiscript.utils.Vec2.equals |
( |
Vec2 |
v | ) |
|
Compares this vector with another one.
Definition at line 238 of file Vec2.java.
◆ insideTriangle()
| boolean cz.zdepav.school.texiscript.utils.Vec2.insideTriangle |
( |
Vec2 |
p1, |
|
|
Vec2 |
p2, |
|
|
Vec2 |
p3 |
|
) |
| |
Checks whether this point is inside a given triangle.
- Parameters
-
| p1 | triangle's first vertex |
| p2 | triangle's second vertex |
| p3 | triangle's third vertex |
- Returns
- True if this point is inside the triangle, false otherwise.
Definition at line 192 of file Vec2.java.
◆ isZero()
| boolean cz.zdepav.school.texiscript.utils.Vec2.isZero |
( |
| ) |
|
Checks whether this vector is equal to a zero vector.
Definition at line 224 of file Vec2.java.
◆ ld() [1/2]
| static Vec2 cz.zdepav.school.texiscript.utils.Vec2.ld |
( |
double |
distance, |
|
|
double |
direction, |
|
|
double |
originX, |
|
|
double |
originY |
|
) |
| |
|
static |
Creates a point with a given distance and direction from another point.
Definition at line 278 of file Vec2.java.
◆ ld() [2/2]
| static Vec2 cz.zdepav.school.texiscript.utils.Vec2.ld |
( |
double |
length, |
|
|
double |
direction |
|
) |
| |
|
static |
Creates a vector with a given length and direction.
Definition at line 273 of file Vec2.java.
◆ ldx() [1/2]
| static double cz.zdepav.school.texiscript.utils.Vec2.ldx |
( |
double |
distance, |
|
|
double |
direction, |
|
|
double |
originX |
|
) |
| |
|
static |
Computes x coordinate of a point with a given distance and direction from another point.
Definition at line 258 of file Vec2.java.
◆ ldx() [2/2]
| static double cz.zdepav.school.texiscript.utils.Vec2.ldx |
( |
double |
length, |
|
|
double |
direction |
|
) |
| |
|
static |
Computes x coordinate of a vector with a given length and direction.
Definition at line 253 of file Vec2.java.
◆ ldy() [1/2]
| static double cz.zdepav.school.texiscript.utils.Vec2.ldy |
( |
double |
distance, |
|
|
double |
direction, |
|
|
double |
originY |
|
) |
| |
|
static |
Computes y coordinate of a point with a given distance and direction from another point.
Definition at line 268 of file Vec2.java.
◆ ldy() [2/2]
| static double cz.zdepav.school.texiscript.utils.Vec2.ldy |
( |
double |
length, |
|
|
double |
direction |
|
) |
| |
|
static |
Computes y coordinate of a vector with a given length and direction.
Definition at line 263 of file Vec2.java.
◆ length()
| double cz.zdepav.school.texiscript.utils.Vec2.length |
( |
| ) |
|
Returns the length of this vector.
Definition at line 25 of file Vec2.java.
◆ lerp()
| Vec2 cz.zdepav.school.texiscript.utils.Vec2.lerp |
( |
Vec2 |
v, |
|
|
double |
ammount |
|
) |
| |
Interpolates between this and other vector using linear interpolation.
- Parameters
-
| v | second vector |
| ammount | interpolation ammount between the two colors (0 ~ this vector, 1 ~ v) |
- Returns
- Resulting vector between this and v.
Definition at line 90 of file Vec2.java.
◆ mul()
| Vec2 cz.zdepav.school.texiscript.utils.Vec2.mul |
( |
double |
f | ) |
|
Multiplies this vector by a scalar value and returns the result.
Definition at line 75 of file Vec2.java.
◆ negate()
| Vec2 cz.zdepav.school.texiscript.utils.Vec2.negate |
( |
| ) |
|
Negates both coordinates of this vector and returns the result.
Definition at line 175 of file Vec2.java.
◆ normal()
| Vec2 cz.zdepav.school.texiscript.utils.Vec2.normal |
( |
| ) |
|
Returns a vector perpendicular to this one.
Definition at line 219 of file Vec2.java.
◆ normalize()
| Vec2 cz.zdepav.school.texiscript.utils.Vec2.normalize |
( |
| ) |
|
Normalizes this vector to a length of 1 and returns the result.
Definition at line 169 of file Vec2.java.
◆ onEllipse() [1/2]
| static Vec2 cz.zdepav.school.texiscript.utils.Vec2.onEllipse |
( |
double |
r1, |
|
|
double |
r2, |
|
|
double |
angle |
|
) |
| |
|
static |
Creates a point on an ellipse with center at 0;0.
Definition at line 298 of file Vec2.java.
◆ onEllipse() [2/2]
| static Vec2 cz.zdepav.school.texiscript.utils.Vec2.onEllipse |
( |
double |
r1, |
|
|
double |
r2, |
|
|
double |
angle, |
|
|
Vec2 |
center |
|
) |
| |
|
static |
Creates a point on an ellipse with a given center.
Definition at line 303 of file Vec2.java.
◆ randUnit() [1/2]
| static Vec2 cz.zdepav.school.texiscript.utils.Vec2.randUnit |
( |
| ) |
|
|
static |
Creates a random unit vector.
Definition at line 286 of file Vec2.java.
◆ randUnit() [2/2]
Creates a random unit vector using a specific random generator.
Definition at line 292 of file Vec2.java.
◆ rotate()
| Vec2 cz.zdepav.school.texiscript.utils.Vec2.rotate |
( |
double |
angle | ) |
|
Rotates this vector around 0;0 by a given angle and returns the result.
- Parameters
-
- Returns
- Resulting vector.
Definition at line 115 of file Vec2.java.
◆ rotateAround()
| Vec2 cz.zdepav.school.texiscript.utils.Vec2.rotateAround |
( |
Vec2 |
origin, |
|
|
double |
angle |
|
) |
| |
Rotates this vector around origin by a given angle and returns the result.
- Parameters
-
| origin | point to rotate around |
| angle | angle in radians |
- Returns
- Resulting vector.
Definition at line 126 of file Vec2.java.
◆ sqrDistanceTo() [1/2]
| double cz.zdepav.school.texiscript.utils.Vec2.sqrDistanceTo |
( |
double |
x, |
|
|
double |
y |
|
) |
| |
Computes second power of the distance from this point to another one.
Definition at line 151 of file Vec2.java.
◆ sqrDistanceTo() [2/2]
| double cz.zdepav.school.texiscript.utils.Vec2.sqrDistanceTo |
( |
Vec2 |
v | ) |
|
Computes second power of the distance from this point to another one.
Definition at line 145 of file Vec2.java.
◆ sqrLength()
| double cz.zdepav.school.texiscript.utils.Vec2.sqrLength |
( |
| ) |
|
Returns the second power of the length of this vector.
Definition at line 30 of file Vec2.java.
◆ sub() [1/2]
| Vec2 cz.zdepav.school.texiscript.utils.Vec2.sub |
( |
double |
x, |
|
|
double |
y |
|
) |
| |
Subtracts another vector from this one and returns the result.
Definition at line 60 of file Vec2.java.
◆ sub() [2/2]
| Vec2 cz.zdepav.school.texiscript.utils.Vec2.sub |
( |
Vec2 |
v | ) |
|
Subtracts another vector from this one and returns the result.
Definition at line 55 of file Vec2.java.
◆ toLength()
| Vec2 cz.zdepav.school.texiscript.utils.Vec2.toLength |
( |
double |
length | ) |
|
Stretches this vector to a given length and returns the result.
Definition at line 180 of file Vec2.java.
◆ toString()
| String cz.zdepav.school.texiscript.utils.Vec2.toString |
( |
| ) |
|
Converts this vector to a string in the format x;y.
Definition at line 248 of file Vec2.java.
| final double cz.zdepav.school.texiscript.utils.Vec2.x |
| final double cz.zdepav.school.texiscript.utils.Vec2.y |
◆ zero
| final Vec2 cz.zdepav.school.texiscript.utils.Vec2.zero = new Vec2(0, 0) |
|
static |
The documentation for this class was generated from the following file:
- src/main/java/cz/zdepav/school/texiscript/utils/Vec2.java


These pictures represent diiferent areas that Nigeria is known for from football, to our food, our culture, our music, festivals, tourist areas and lots more. So while at looking at these pictures I would Love you to Envisage yourself having a feel of all these elements.
https://wazobiaafricankitchen.com/wp-content/uploads/food34.jpg, https://www.carnivaland.net/wp-content/uploads/calabar-carnival.jpg,https://www.propertypro.ng/blog/wp-content/uploads/2018/03/Olumo-rock.jpg,https://www.theparisreview.org/il/e4b8f842fe/large/Chinua-Achebe.jpg,https://dailypost.ng/wp-content/uploads/2017/01/Wole-Soyinka-453.jpg,https://wazobiaafricankitchen.com/wp-content/uploads/food34.jpg,https://www.carnivaland.net/wp-content/uploads/calabar-carnival.jpg,https://connectnigeria.com/articles/wp-content/uploads/2013/08/National-Arts-Theatre-Lagos1.jpg,https://images.unsplash.com/photo-1540247110674-31e928ee852a?ixlib=rb-1.2.1&q=85&fm=jpg&crop=entropy&cs=srgb&dl=26everything-films-photos-eS_aZA5S42Y-unsplash.jpg,https://images.unsplash.com/flagged/photo-1559264243-77e7b0942b77?ixlib=rb-1.2.1&q=85&fm=jpg&crop=entropy&cs=srgb&dl=oladimeji-ajegbile-ZEjk5MY5hp4-unsplash.jpg,https://gfycat.com/gifs/search/nigeria+flag,google.com


--- layout: menu title: Hello World! tagline: Supporting tagline --- {% include JB/setup %} {% assign index = true %}
{{ book.perface }}


#Build: Synplify Pro J-2015.03L-SP1, Build 123R, Aug 18 2015 #install: E:\lscc\iCEcube2.2015.08\synpbase #OS: Windows 7 6.1 #Hostname: USER7_X86-PC #Implementation: ice40blinkingled_Implmnt Synopsys HDL Compiler, version comp201503sp1p1, Build 117R, built Aug 18 2015 @N: : | Running in 32-bit mode Copyright (C) 1994-2015 Synopsys, Inc. This software and the associated documentation are proprietary to Synopsys, Inc. This software may only be used in accordance with the terms and conditions of a written license agreement with Synopsys, Inc. All other use, reproduction, or distribution of this software is strictly prohibited. Synopsys Verilog Compiler, version comp201503sp1p1, Build 117R, built Aug 18 2015 @N: : | Running in 32-bit mode Copyright (C) 1994-2015 Synopsys, Inc. This software and the associated documentation are proprietary to Synopsys, Inc. This software may only be used in accordance with the terms and conditions of a written license agreement with Synopsys, Inc. All other use, reproduction, or distribution of this software is strictly prohibited. @I::"E:\lscc\iCEcube2.2015.08\synpbase\lib\generic\sb_ice40.v" @I::"E:\lscc\iCEcube2.2015.08\synpbase\lib\vlog\hypermods.v" @I::"E:\lscc\iCEcube2.2015.08\synpbase\lib\vlog\umr_capim.v" @I::"E:\lscc\iCEcube2.2015.08\synpbase\lib\vlog\scemi_objects.v" @I::"E:\lscc\iCEcube2.2015.08\synpbase\lib\vlog\scemi_pipes.svh" @I::"E:\lscc\projects\ice40blinkingled\ice40blinkingled\ice40blinkingled_rtl.v" Verilog syntax check successful! File E:\lscc\projects\ice40blinkingled\ice40blinkingled_rtl.v changed - recompiling Selecting top level module led_but_ex1 @N:CG364 : ice40blinkingled_rtl.v(1) | Synthesizing module led_but_ex1 At c_ver Exit (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 38MB peak: 39MB) Process took 0h:00m:01s realtime, 0h:00m:01s cputime # Mon Jul 18 09:40:36 2016 ###########################################################] Synopsys Netlist Linker, version comp201503sp1p1, Build 117R, built Aug 18 2015 @N: : | Running in 32-bit mode @N:NF107 : ice40blinkingled_rtl.v(1) | Selected library: work cell: led_but_ex1 view verilog as top level @N:NF107 : ice40blinkingled_rtl.v(1) | Selected library: work cell: led_but_ex1 view verilog as top level At syn_nfilter Exit (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 36MB peak: 36MB) Process took 0h:00m:01s realtime, 0h:00m:01s cputime # Mon Jul 18 09:40:37 2016 ###########################################################] @END At c_hdl Exit (Real Time elapsed 0h:00m:02s; CPU Time elapsed 0h:00m:00s; Memory used current: 3MB peak: 3MB) Process took 0h:00m:02s realtime, 0h:00m:01s cputime # Mon Jul 18 09:40:37 2016 ###########################################################] Synopsys Netlist Linker, version comp201503sp1p1, Build 117R, built Aug 18 2015 @N: : | Running in 32-bit mode File E:\lscc\projects\ice40blinkingled\ice40blinkingled\ice40blinkingled_Implmnt\synwork\ice40blinkingled_comp.srs changed - recompiling @N:NF107 : ice40blinkingled_rtl.v(1) | Selected library: work cell: led_but_ex1 view verilog as top level @N:NF107 : ice40blinkingled_rtl.v(1) | Selected library: work cell: led_but_ex1 view verilog as top level At syn_nfilter Exit (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 36MB peak: 36MB) Process took 0h:00m:01s realtime, 0h:00m:01s cputime # Mon Jul 18 09:40:40 2016 ###########################################################] Pre-mapping Report Synopsys Lattice Technology Pre-mapping, Version maplat, Build 1264R, Built Aug 18 2015 10:12:39 Copyright (C) 1994-2015, Synopsys, Inc. This software and the associated documentation are proprietary to Synopsys, Inc. This software may only be used in accordance with the terms and conditions of a written license agreement with Synopsys, Inc. All other use, reproduction, or distribution of this software is strictly prohibited. Product Version J-2015.03L-SP1 Mapper Startup Complete (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 56MB peak: 56MB) Reading constraint file: E:\lscc\projects\ice40blinkingled\ice40blinkingled\ice40blinkingled_sbt.sdc Linked File: ice40blinkingled_scck.rpt Printing clock summary report in "E:\lscc\projects\ice40blinkingled\ice40blinkingled\ice40blinkingled_Implmnt\ice40blinkingled_scck.rpt" file @N:MF249 : | Running in 32-bit mode. @N:MF666 : | Clock conversion enabled Design Input Complete (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 57MB peak: 59MB) Mapper Initialization Complete (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 57MB peak: 59MB) Start loading timing files (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 58MB peak: 59MB) Finished loading timing files (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 58MB peak: 60MB) ICG Latch Removal Summary: Number of ICG latches removed: 0 Number of ICG latches not removed: 0 syn_allowed_resources : blockrams=16 set on top level netlist led_but_ex1 Finished netlist restructuring (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 76MB peak: 79MB) @S |Clock Summary ***************** Start Requested Requested Clock Clock Clock Frequency Period Type Group ------------------------------------------------------------------------------------------------------------- CLK 100.0 MHz 10.000 declared default_clkgroup led_but_ex1|clk_div_derived_clock[11] 100.0 MHz 10.000 derived (from CLK) default_clkgroup ============================================================================================================= Finished Pre Mapping Phase. @N:BN225 : | Writing default property annotation file E:\lscc\projects\ice40blinkingled\ice40blinkingled\ice40blinkingled_Implmnt\ice40blinkingled.sap. Pre-mapping successful! At Mapper Exit (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 44MB peak: 79MB) Process took 0h:00m:01s realtime, 0h:00m:01s cputime # Mon Jul 18 09:40:44 2016 ###########################################################] Map & Optimize Report Synopsys Lattice Technology Mapper, Version maplat, Build 1264R, Built Aug 18 2015 10:12:39 Copyright (C) 1994-2015, Synopsys, Inc. This software and the associated documentation are proprietary to Synopsys, Inc. This software may only be used in accordance with the terms and conditions of a written license agreement with Synopsys, Inc. All other use, reproduction, or distribution of this software is strictly prohibited. Product Version J-2015.03L-SP1 Mapper Startup Complete (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 56MB peak: 57MB) @N:MF249 : | Running in 32-bit mode. @N:MF666 : | Clock conversion enabled Design Input Complete (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 55MB peak: 58MB) Mapper Initialization Complete (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 55MB peak: 58MB) Start loading timing files (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 57MB peak: 58MB) Finished loading timing files (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 58MB peak: 60MB) Starting Optimization and Mapping (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 77MB peak: 79MB) Available hyper_sources - for debug and ip models None Found @N:MT204 : | Auto Constrain mode is disabled because clocks are defined in the SDC file CLK Finished RTL optimizations (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 77MB peak: 79MB) Finished factoring (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 77MB peak: 79MB) Finished gated-clock and generated-clock conversion (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 77MB peak: 79MB) Finished generic timing optimizations - Pass 1 (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 78MB peak: 79MB) Starting Early Timing Optimization (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 78MB peak: 79MB) Finished Early Timing Optimization (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 78MB peak: 79MB) Finished generic timing optimizations - Pass 2 (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 78MB peak: 79MB) Finished preparing to map (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 78MB peak: 79MB) Finished technology mapping (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 78MB peak: 79MB) Pass CPU time Worst Slack Luts / Registers ------------------------------------------------------------ 1 0h:00m:00s 3.15ns 78 / 49 @N:FX1016 : ice40blinkingled_rtl.v(9) | SB_GB_IO inserted on the port CLK. @N:FX1017 : | SB_GB inserted on the net N_16. Finished technology timing optimizations and critical path resynthesis (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 78MB peak: 79MB) Finished restoring hierarchy (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 78MB peak: 79MB) @N:MT611 : | Automatically generated clock led_but_ex1|clk_div_derived_clock[11] is not used and is being removed #### START OF CLOCK OPTIMIZATION REPORT #####[ 1 non-gated/non-generated clock tree(s) driving 49 clock pin(s) of sequential element(s) 0 gated/generated clock tree(s) driving 0 clock pin(s) of sequential element(s) 37 instances converted, 0 sequential instances remain driven by gated/generated clocks =========================== Non-Gated/Non-Generated Clocks ============================ Clock Tree ID Driving Element Drive Element Type Fanout Sample Instance --------------------------------------------------------------------------------------- ClockId0001 CLK_ibuf_gb_io SB_GB_IO 49 rst_cnt_esr[14] ======================================================================================= ##### END OF CLOCK OPTIMIZATION REPORT ######] Start Writing Netlists (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 65MB peak: 79MB) Writing Analyst data base E:\lscc\projects\ice40blinkingled\ice40blinkingled\ice40blinkingled_Implmnt\synwork\ice40blinkingled_m.srm Finished Writing Netlist Databases (Real Time elapsed 0h:00m:01s; CPU Time elapsed 0h:00m:01s; Memory used current: 78MB peak: 79MB) Writing EDIF Netlist and constraint files @N:BW103 : | Synopsys Constraint File time units using default value of 1ns @N:BW107 : | Synopsys Constraint File capacitance units using default value of 1pF J-2015.03L-SP1 Finished Writing EDIF Netlist and constraint files (Real Time elapsed 0h:00m:01s; CPU Time elapsed 0h:00m:01s; Memory used current: 78MB peak: 79MB) Start final timing analysis (Real Time elapsed 0h:00m:01s; CPU Time elapsed 0h:00m:01s; Memory used current: 79MB peak: 79MB) Found clock CLK with period 10.00ns @S |##### START OF TIMING REPORT #####[ # Timing Report written on Mon Jul 18 09:40:47 2016 # Top view: led_but_ex1 Requested Frequency: 100.0 MHz Wire load mode: top Paths requested: 5 Constraint File(s): E:\lscc\projects\ice40blinkingled\ice40blinkingled\ice40blinkingled_sbt.sdc @N:MT320 : | Timing report estimates place and route data. Please look at the place and route timing report for final timing. @N:MT322 : | Clock constraints cover only FF-to-FF paths associated with the clock. Performance Summary ******************* Worst slack in design: 0.158 Requested Estimated Requested Estimated Clock Clock Starting Clock Frequency Frequency Period Period Slack Type Group ------------------------------------------------------------------------------------------------------------------ CLK 100.0 MHz 101.6 MHz 10.000 9.842 0.158 declared default_clkgroup ================================================================================================================== Clock Relationships ******************* Clocks | rise to rise | fall to fall | rise to fall | fall to rise -------------------------------------------------------------------------------------------------------- Starting Ending | constraint slack | constraint slack | constraint slack | constraint slack -------------------------------------------------------------------------------------------------------- CLK CLK | 10.000 0.158 | No paths - | No paths - | No paths - ======================================================================================================== Note: 'No paths' indicates there are no paths in the design for that pair of clock edges. 'Diff grp' indicates that paths exist but the starting clock and ending clock are in different clock groups. Interface Information ********************* No IO constraint found ==================================== Detailed Report for Clock: CLK ==================================== Starting Points with Worst Slack ******************************** Starting Arrival Instance Reference Type Pin Net Time Slack Clock --------------------------------------------------------------------------------- clk_div[1] CLK SB_DFF Q clk_div[1] 0.540 0.158 clk_div[0] CLK SB_DFF Q clk_div[0] 0.540 0.289 clk_div[2] CLK SB_DFF Q clk_div[2] 0.540 0.298 clk_div[3] CLK SB_DFF Q clk_div[3] 0.540 0.438 cntr[6] CLK SB_DFFE Q cntr[6] 0.540 0.439 cntr[10] CLK SB_DFFE Q cntr[10] 0.540 0.439 cntr[4] CLK SB_DFFE Q cntr[4] 0.540 0.488 cntr[8] CLK SB_DFFE Q cntr[8] 0.540 0.488 cntr[11] CLK SB_DFFE Q cntr[11] 0.540 0.488 cntr[9] CLK SB_DFFE Q cntr[9] 0.540 0.509 ================================================================================= Ending Points with Worst Slack ****************************** Starting Required Instance Reference Type Pin Net Time Slack Clock ------------------------------------------------------------------------------------------------ mode CLK SB_DFF D mode_0 9.895 0.158 LED2_m1_r CLK SB_DFFSR D LED2_m1_r_en 9.895 0.207 LED1_m1_r CLK SB_DFFSS D LED1_m1_r_en 9.895 0.228 rst_cnt_esr[14] CLK SB_DFFESR E N_16_0 10.000 0.333 LED1_m1_r CLK SB_DFFSS S cntr_RNITQ4V2[14] 9.895 0.439 LED2_m1_r CLK SB_DFFSR R cntr_RNITQ4V2[14] 9.895 0.439 cntr[5] CLK SB_DFFE D cntr_3[5] 9.895 0.453 cntr[6] CLK SB_DFFE D cntr_3[6] 9.895 0.453 cntr[8] CLK SB_DFFE D cntr_3[8] 9.895 0.453 cntr[9] CLK SB_DFFE D cntr_3[9] 9.895 0.453 ================================================================================================ Worst Path Information View Worst Path in Analyst *********************** Path information for path number 1: Requested Period: 10.000 - Setup time: 0.105 + Clock delay at ending point: 0.000 (ideal) = Required time: 9.895 - Propagation time: 9.737 - Clock delay at starting point: 0.000 (ideal) = Slack (critical) : 0.158 Number of logic level(s): 15 Starting point: clk_div[1] / Q Ending point: mode / D The start point is clocked by CLK [rising] on pin C The end point is clocked by CLK [rising] on pin C Instance / Net Pin Pin Arrival No. of Name Type Name Dir Delay Time Fan Out(s) ----------------------------------------------------------------------------------------------------------------- clk_div[1] SB_DFF Q Out 0.540 0.540 - clk_div[1] Net - - 0.834 - 3 clk_div_RNI91U1[1] SB_CARRY I0 In - 1.374 - clk_div_RNI91U1[1] SB_CARRY CO Out 0.258 1.632 - clk_div_2_cry_1 Net - - 0.014 - 1 clk_div_RNIF3T2[2] SB_CARRY CI In - 1.646 - clk_div_RNIF3T2[2] SB_CARRY CO Out 0.126 1.772 - clk_div_2_cry_2 Net - - 0.014 - 1 clk_div_RNIM6S3[3] SB_CARRY CI In - 1.786 - clk_div_RNIM6S3[3] SB_CARRY CO Out 0.126 1.912 - clk_div_2_cry_3 Net - - 0.014 - 1 clk_div_RNIUAR4[4] SB_CARRY CI In - 1.926 - clk_div_RNIUAR4[4] SB_CARRY CO Out 0.126 2.052 - clk_div_2_cry_4 Net - - 0.014 - 1 clk_div_RNI7GQ5[5] SB_CARRY CI In - 2.066 - clk_div_RNI7GQ5[5] SB_CARRY CO Out 0.126 2.192 - clk_div_2_cry_5 Net - - 0.014 - 1 clk_div_RNIHMP6[6] SB_CARRY CI In - 2.206 - clk_div_RNIHMP6[6] SB_CARRY CO Out 0.126 2.333 - clk_div_2_cry_6 Net - - 0.014 - 1 clk_div_RNISTO7[7] SB_CARRY CI In - 2.346 - clk_div_RNISTO7[7] SB_CARRY CO Out 0.126 2.473 - clk_div_2_cry_7 Net - - 0.014 - 1 clk_div_RNI86O8[8] SB_CARRY CI In - 2.487 - clk_div_RNI86O8[8] SB_CARRY CO Out 0.126 2.613 - clk_div_2_cry_8 Net - - 0.014 - 1 clk_div_RNILFN9[9] SB_CARRY CI In - 2.627 - clk_div_RNILFN9[9] SB_CARRY CO Out 0.126 2.753 - clk_div_2_cry_9 Net - - 0.014 - 1 clk_div_RNIAAMP[10] SB_CARRY CI In - 2.767 - clk_div_RNIAAMP[10] SB_CARRY CO Out 0.126 2.893 - clk_div_2_cry_10 Net - - 0.386 - 1 clk_div_RNI06L91[11] SB_LUT4 I3 In - 3.279 - clk_div_RNI06L91[11] SB_LUT4 O Out 0.316 3.595 - clk_div_RNI06L91[11] Net - - 1.371 - 2 clk_div_RNIM1KP1[11] SB_LUT4 I0 In - 4.966 - clk_div_RNIM1KP1[11] SB_LUT4 O Out 0.449 5.415 - clk_div_RNIM1KP1[11] Net - - 0.000 - 1 clk_div_RNIM1KP1_0[11] SB_GB USER_SIGNAL_TO_GLOBAL_BUFFER In - 5.415 - clk_div_RNIM1KP1_0[11] SB_GB GLOBAL_BUFFER_OUTPUT Out 0.617 6.032 - N_16_g Net - - 0.000 - 37 BUT1_r_RNIKV9M2 SB_LUT4 I2 In - 6.032 - BUT1_r_RNIKV9M2 SB_LUT4 O Out 0.379 6.410 - BUT1_r_RNIKV9M2 Net - - 1.371 - 17 mode_RNO SB_LUT4 I0 In - 7.782 - mode_RNO SB_LUT4 O Out 0.449 8.230 - mode_0 Net - - 1.507 - 1 mode SB_DFF D In - 9.737 - ================================================================================================================= Total path delay (propagation time + setup) of 9.842 is 4.248(43.2%) logic and 5.595(56.8%) route. Path delay compensated for clock skew. Clock skew is added to clock-to-out value, and is subtracted from setup time value ##### END OF TIMING REPORT #####] Finished final timing analysis (Real Time elapsed 0h:00m:01s; CPU Time elapsed 0h:00m:01s; Memory used current: 79MB peak: 80MB) Finished timing report (Real Time elapsed 0h:00m:01s; CPU Time elapsed 0h:00m:01s; Memory used current: 79MB peak: 80MB) --------------------------------------- Resource Usage Report for led_but_ex1 Mapping to part: ice40hx1kvq100 Cell usage: SB_CARRY 46 uses SB_DFF 13 uses SB_DFFE 19 uses SB_DFFESR 1 use SB_DFFSR 15 uses SB_DFFSS 1 use SB_GB 1 use SB_LUT4 70 uses I/O ports: 5 I/O primitives: 5 SB_GB_IO 1 use SB_IO 4 uses I/O Register bits: 0 Register bits not including I/Os: 49 (3%) Total load per clock: CLK: 1 Mapping Summary: Total LUTs: 70 (5%) Distribution of All Consumed LUTs = LUT4 Distribution of All Consumed Luts 70 = 70 Mapper successful! At Mapper Exit (Real Time elapsed 0h:00m:01s; CPU Time elapsed 0h:00m:01s; Memory used current: 38MB peak: 80MB) Process took 0h:00m:01s realtime, 0h:00m:01s cputime # Mon Jul 18 09:40:47 2016 ###########################################################]


codon .() usage genes lactiflora bias ENC Codon content codons expression nucleotide {border-style .(,) gene synonymous Figure px;} selection used #ffffff;} < analysis CAI genome values mutation correlation Axis composition value contents length main protein Analysis Genes Mol. Res. based expected lactiflora. number patterns plot shaping significant significantly using Synonymous genome, position px; suggesting {font-family Nucleic calculated codons. database font-size level levels mutational optimal overall reconstructed results study, translational Acids Correspondence Evol. Plot RSCU Table Usage bias, bias. different double; evolution evolutionary factors influenced low points ranged sequences shown slightly transcriptome Biol. Codons Gene P.M. Parity Rule Sharp amino analyses analyzed biased border-color border-width correlations curve, determined genome. important indicating measure observed organisms pattern pressure role solid; usage. {font-style {font-weight (.%) (GC (mean .%; .%–.% .), ./nar/.. Based CDS Correlation GC, Genet. Neutrality Paeonia Proc. RSCU(N) Tao Transcriptome analysis. analyze axis bold close content, correlated corresponding courier; data distribution em; exogenous focused genetic high influence investigated major mean molecular multivariate neutrality organisms, plotted pt;} range relationship respectively, second sequence sequencing showed structure suggested useful vs. −.,


---
layout: blogpost
title: Weekend Excursions - First month in Europe
comments: true
date: 5th October 2016
pc: Silva, Prayaag, Gaurav, Sagar, Pabitra, Manish, Alap, Sarthak, Kavitha
---
Preface
Travelogue of weekend excursions taken during first month of exchange semester at RWTH Aachen, Germany (September 2016-17)
The famous beer festival ‘Oktoberfest’ in Munich was scheduled to begin from 17th September 2016. It is the world’s largest folk festival running from mid September to first weekend of October, with over 6 million people attending the festival and drinking a hell lot of beer!. We were eager to go to Munich for the opening day of this festival (even though many of us were teetotalers) as it featured many exciting events, apart from the beer-action. We decided to go with Studifahrten for this 'Oktoberfest' Munich trip. Studifahrten is a company which organizes budget tours for students in Europe
We boarded Studifahrten's double decker bus from the landmark ‘Super-C’ building in Aachen on Friday night. As we had reached the boarding point an hour before departure, we were able to grab the premium ‘balcony’ seats on the upper deck. These seats provided panoramic views, and also had bigger legroom. The night journey across Germany was peaceful as we relaxed in our seats and enjoyed the night landscapes.
The bus stopped in a couple of cities to pick up other passengers and reached Munich early in the morning on Saturday. The weather in Munich was cloudy and a bit cold, with drizzles expected throughout the day. But the rain couldn’t stop our excitement and enthusiasm to explore this capital and largest city of Germany's ‘Bavaria’ state. We walked from ZOB (Central bus station) to Munich Hauptbahnof (Central Railway station), enjoying the first glimpses of the city. We bought a group day ticket for public transport in Munich and decided to start our sightseeing tour from the famous ‘Allianz arena’. The home of Germany’s most famous football club: FC Bayern Munich! This futuristic stadium is widely known for it’s exterior of inflated ETFE plastic panels and it is the first stadium in the world with a full colour changing exterior. It's the dream of every football fan to visit this stadium and watch a game here.
It was a spectacular sight indeed! The guided tours of the stadium and FC Bayern experience center were closed, as it was a game day. We tried to get game tickets with the help of an official, but later dropped the idea as it was a costly affair.
After roaming around the Allianz arena for about an hour, we left towards our next destinations: BMW Museum and the Olympiapark, both situated in the Olympiazentrum area. The BMW museum had a hefty entry fee so we decided to skip it and visited the neighbouring ‘BMW Welt’. BMW has recently opened this building to complement the company’s state of the art museum and the building has really impressive architecture, both inside and outside. A wide range of spectacular BMW cars were showcased inside and we couldn’t stop ourselves from clicking pictures from every possible angle.
There was also an ‘Augmented reality’ exhibit named ‘BMW vision’ where we could click photos with a virtual futuristic car.
Next to the BMW Welt, the ‘Olympiapark’ spreads across a huge area. Built for the 1972 Olympics, the park is now the hotspot for sports, music and leisure. The uniquely constructed rooftop and stadiums are truly legendary!
After visiting the Olympia park, we went straight to the most happening place in the city: the ‘Oktoberfest area’ in Theresienwiese . It was forbidden to carry backpacks inside the area, so we decided to split in two groups: teetotalers and drinkers. Five of us (teetotalers) went in first, while others stayed outside with our luggage.
The atmosphere inside the Oktoberfest area was extremely energetic and cheerful! In spite of the continuous rain, thousands of people were roaming in this huge area. The streets and shops were bustling with young couples and groups, giving it a feel of world’s largest fun fair.
A monumental, bronze cast statue named ‘Bavaria’ (female personification of the bavarian homeland) situated on a hill above the Theresienwiese added to the spectacle.
After enjoying the awesome ‘feel’ of Oktoberfest for more than an hour, we had to turn back (unwillingly!) and let the ‘drinkers’ group’ enter the area. As they went in, we teetotalers took shelter below the canopy of a house and watched the tradionally-dressed people exiting the Oktoberfest area. Some of them were shouting jovially to express their happiness while others were too drunk to walk straight :P
After the drinkers’ group returned, we went back to the hauptbahnhof and boarded the metro towards : ‘Marienplatz’. This central area of the city looked amazing in the lights with the spectacular twin onion-domed towers of the ‘Frauenkirche’ cathedral in the background.
We walked up to the ‘Frauenkirche’, the Gothic cathedral and parish church, and also a distinctive landmark of this Bavarian capital. We sat inside for half an hour, relaxing (we had walked more than 15kms in a single day!), and connecting with the inner divinity.
As the clock struck 8PM, we headed back to the bus and departed towards Aachen with wonderful memories of a day-well-spent-in-Munich!


Each Circumflex web application is composed of one or more request routers. Request router is a subclass of RequestRouter
which sequentionally defines routes directly within its body:
class Main extends RequestRouter {
get("/") = "Hello world!"
get("/posts/:id") = "Post #" + uri.get("id")
post("/form") = {
// Do some work
// . . .
// Render FreeMarker template:
ftl("/done.ftl")
}
}
Request routers are essentially the controllers of the application. Since Circumflex Web Framework employs the Front Controller pattern, each web application should have a single main router — a special RequestRouter
which gets executed on every request. It dispatches all requests of web application.
Request routers can also be easily nested:
class MainRouter extends RequestRouter {
// with matching
any("/users/*") => new UsersRouter
any("/posts/*") => new PostsRouter
any("/mail/*") => new MailRouter
any("/downloads/*") => new DownloadsRouter
// unconditionally
new MiscRouter
}
It is generally a good practice to have different routers for different tasks — it makes the code modular, more organized and easier to maintain.
Circumflex Web Framework is designed around the route concept. A route is an HTTP method with matching mechanism and attached block.
Routes are defined using one of the following members of RequestRouter
:
get
(matches HTTP GET
requests);post
(matches HTTP POST
requests);put
(matches HTTP PUT
requests);patch
(matches HTTP PATCH
requests);delete
(matches HTTP DELETE
requests);options
(matches HTTP OPTIONS
requests);head
(matches HTTP HEAD
requests);getOrHead
(matches either HTTP GET
or HTTP HEAD
);getOrPost
(matches either HTTP GET
or HTTP POST
);any
(matches any HTTP request).Each route should define a matcher, which describes the conditions a request must satisfy to be matched by the route.
Each route also has an associated block which gets executed if matching succeeds. A block must evaluate to RouteResponse
which will be sent to client (String
and scala.xml.Node
are converted to RouteResponse
implicitly):
class MyRouter extends RequestRouter {
get("/hello/:name.txt") = "Hello, " + param("name") + "!"
get("/hello/:name.xml") = {
val name = param("name")
<hello to={name}/>
}
}
Upon successful matching the block attached to corresponding route gets executed. Internally we use ResponseSentException
, a special control throwable, to indicate that request processing has been finished. This exception is caught by CircumflexFilter
which performs response flushing and finalizes request processing.
Various helpers throw ResponseSentException
instead of yielding RouteResponse
:
get("/") = redirect("/index.html")
Request matching can be performed against request URI and zero or more request headers. The syntax is self-descriptive:
get("/") // matches GET /
get("/posts") // matches GET /posts
post("/posts") // matches POST /posts
You can combine several matchers in one route using the &
method:
get("/mail" & Accept("text/html") & Host("localhost"))
// matches following request:
// GET /mail
// Host: localhost
// Accept: text/html
Routes can include patterns with named parameters which can be accessed in the attached block. The following route matches GET /posts/43
or GET /posts/foo
; the construct uri("id")
is used to capture the parameter from request URI:
get("/posts/:id") = "Post #" + uri("id")
Route patterns may also include wildcard parameters (*
for zero or more characters, +
for one or more characters), they can be accessed via index (starting with 1
like in regex groups):
get("/files/+") = "Downloading file " + uri(1)
You may also refer to the whole match with 0
index:
get("/files/:name.:ext") = {
println("The URI is: " + uri(0))
"Filename is " + uri("name") + ", extension is " + uri("ext")
}
Named parameters are indexed too:
get("*/:two/+/:four") = {
// uri(2) == uri("two")
// uri(4) == uri("four")
(1 to 4).map(i => i + " -> " + uri(i)).mkString("\n")
}
Parameters can also be extracted using the param
helper. Unlike uri
, which represents match results from URI only, the param
helper can extract named parameters from headers:
get("/" & Accept("text/:format")) = "The format is " + param("format")
You can also extract request parameters using param
:
get("/") = "Limit is " + param("limit") + ", offset is " + param.getOrElse("offset", "0")
// >> GET /?limit=50&offset=10
// << Limit is 50, offset is 10
// >> GET /?limit=5
// << Limit is 5, offset is 0
By default static files are served from <webapp_root>/public
directory. You may override this by setting cx.public
configuration parameter.
You can send 302 Found
HTTP redirect:
get("/") = sendRedirect("/index.html")
You can also perform request forwarding (a.k.a. URI rewriting) — the request will be dispatched again, but with different URI):
get("/") = forward("/index.html")
Note that you should add <dispatcher>FORWARD</dispatcher>
to CircumflexFilter
mapping in your web.xml
to make forwarding work. You should also avoid infinite forwarding loops manually.
You can send errors with specific status code and optional message:
get("/") = sendError(500, "We don't work yet.")
You can use the sendFile
helper to send arbitrary file to client:
get("/") = sendFile(new File("/path/to/file.txt"))
You can also specify optional filename
so that Content-Disposition: attachment
could be added to response:
get("/") = sendFile(new File("/path/to/file.txt"), "greetings.txt")
The content type of the file is guessed based on it's extension. You may override it:
get("/") = {
response.contentType("text/plain")
sendFile(new File("/path/to/file.text"), "greetings.txt")
}
You can also use the more efficient xSendFile
helper to delegate the file transfering to your web server. This feature is configured via cx.XSendFile
configuration parameter. Consult your web server documentation to obtain more information on this feature.
You can determine if current request is XmlHttpRequest
:
get("/") = if (request.body.xhr_?) "AJAX" else "plain old request"
You get the contents of request headers using the header
helper:
get("/") = "Serving to host: " + headers("Host")
Dealing with session attributes is fairly easy:
get("/") = {
// get attribute
session("attr1")
// set attribute
session("attr2") = "My value"
}
Flashes provide a way to pass temporary objects between requests:
get("/") = flash.get("note") match {
case Some(value) => "Having a note: " + value
case None => "No notes for now..."
}
post("/") = {
flash("note") = "Hello from POST, folks!"
redirect("/")
}
Anything you place in flash
helper will be exposed until the first lookup and then cleared out. This is a great way of dealing with notices and alerts which only need to be shown once.


The grouping feature allows you to group rows together based on similar values in specific columns, providing an effect similar in some ways to an Excel pivot table. Columns that aren't grouped by can be aggregated, providing for example a running count of the number of rows in each group.
_** BREAKING CHANGES IN RC22 for grouping. Prior to RC22 grouping was a standalone feature, with RC22 a number of things have changed as grouping and treeView move to a shared code base. In particular:
Documentation for the grouping feature is provided in the api documentation, both under grouping itself, and shared functions in the treeBase documentation. In particular:
The tree structure itself is documented at treeBase.
Grouping can be set programmatically by using the columnDef option grouping: { groupPriority: 0 }
,
or for aggregations on a column by setting treeAggregation: {type: uiGridGroupingConstants.aggregation.COUNT}
.
Optionally (and by default) grouped columns are moved to the front of the grid, which provides a more visually pleasing effect. In order to avoid creating a dependency on pinning, this is done by moving the columns themselves as part of the grouping feature, not through use of the pinning feature.
Grouping leverages the sort functionality, allowing a user to change the sort order or use external sort functionality and have the resulting list grouped. A column(s) that is marked as being grouped is always moved to the high order of the sort priority, as the data must be sorted to permit grouping.
Any grouped column has suppressRemoveSort
set, when a column is ungrouped then suppressRemoveSort
is returned to the value in the columnDef.
Grouping and aggregation should work cleanly with filtering - it should group and aggregate only the filtered rows.
Group header rows cannot be edited, and if using the selection feature, cannot be selected. They can, however, be exported.
The group rowHeader by default is always visible. If you'd like the groupRowHeader only
present when at least one column is grouped then set the treeRowHeaderAlwaysVisible: false
gridOption.
If you want to change the grouping programmatically after grid initialisation, you do this through calling the provided methods:
groupColumn
: groups an individual column. Adds it to the end of the current grouping - so you need to remove
existing grouped columns first if you wanted this to be the only grouping.  Automatically removes
any sort first.setGrouping
: sets all the grouping in one go, removing existing groupinggetGrouping
: gets the grouping config for the gridclearGrouping
: clears all current grouping settingsGrouping is still alpha, and under development, however it is included in the distribution files to allow people to start using it. Notable outstandings are:
Options to watch out for include:
treeIndent
: the expand buttons are indented by a number of pixels (default 10) as the grouping
level gets deeper. Larger values look nicer, but take up more spacetreeRowHeaderBaseWidth
: the base width of the grouping row header (default 30)customTreeAggregationFinalizerFn
: if your column has a cellFilter, the insertion of text (e.g. 'min: xxxx')
usually breaks the cellFilter. You can define a custom aggregation finalizer that handles this text differently,
either applying the filter in code, or skipping the inclusion of the aggregation text. This can also be used
to skip the showing of the counts at allIf you would like to suppress the data in a grouped column (so it only shows in the groupHeader rows) this can be done by overriding the cellTemplate for any of the columns you allow grouping on as follows:
cellTemplate: '
{{COL_FIELD CUSTOM_FILTERS}}
'
In the example below this has been done on the state column only. This isn't included in the base code as it could potentially interact with people's custom templates.
Tuning the way aggregations work can be done through defining a columnsProcessor that runs with higher (later) priority than the groupingColumnProcessor (so higher than 400), and that looks for grouped or aggregated columns and changes things like the treeAggregationFn, or the customTreeAggregationFinalizerFn. See tutorial 320 for an example.
For better performance with the following example, you can choose to load the ui-grid.core.js and specific feature files instead:

In this example we group by the state column then the gender column, and we count the names (a proxy for counting the number of rows), we find the max age for each grouping, and we calculate the average balance. We suppress the aggregation text on the balance column because we want to format as currency...but that means that we can't easily see that it's an average.
We write a function that extracts the aggregated data for states and genders (if you change the grouping then this function will stop working), and writes them to the console.


????? ???????
on 2012-04-23 14:50:39
If I might —perhaps you should consider adding a few images. I don’t mean to disrespect what you’ve said ; its very enlightening, indeed. However, I think would respond to it more positively if they could be something tangible to your ideas
Brett Zamir
on 2009-12-20 09:59:40
@Rey: Did some of your post get cut off? No idea what you're talking about... We don't want to install anything to test too, so please include whatever code you want to highlight here (or use a site like pastebin.org and refer us to it)
Rey S.
on 2009-12-19 23:03:27
javascript: a76883600569_do_hosp("heal","7667eddaf89376258610b9df58d1d54dda64721c");
As to use this string and to make it to work in a platform of a game of Facebook. The code of 40 figures and the key of the personage.
Thanks
http://apps.facebook.com/guerre-di-banda/hospital.php


Google
Welcome to Mr. Roboger's Neighborhood!
Select number below
Submit
Number:
Thank you for participating!
Leave input
BYE


| New change request | #{0} |
| Request details | |
| Requester | {1} |
|
|
|
| Group name | {2} |
|
|
|
| App name | {3} |
| Event details | |
| Action | {4} |
| Domain | {5} |
| State | Pending validation |
| Steps to validate | |
|
Log in to the Enterprise Mode Site List Portal by clicking here.


Vineet
Vineet Sethia is an undergrad student of CSE at NIT Surat,India.He is the member of various student chapters & organizations like Google Developer Group (GDG),Firefox Student Ambassadors,Association For Computing Machinary (ACM).His primary interest lies in Artificial Intelligence,Information Security,Networking,Algorithms & Web Development.Recently,He joined the Stanford HCI CrowdSource Research Program.He likes reading,playing chess,listening music & exploring new places.
Contact him at:vineetsethia3@gmail.com


Welcome to Bitr! Feel free to search through our users public posts using the search box above or register an account and contribute your own content! Make sure you check out our various media posting features and post-chain tracking.
Bitr is like twitter, but Betr.


OCTOBER 7 Our Lady of the Rosary
This Marian
celebration originated from the victory of Lepanto (1571). The combined Christian
fleet defeated the forces of the Turks, thus arresting their occupation of
ENTRANCE ANTIPHON
Hail, Mary, full of grace, the Lord is with you. Blessed are you among women and blessed is the fruit of your womb.
The
GLORIA can be said
COLLECT
Pour forth, we beseech you, O Lord, your grace into our hearts, that we, to whom the Incarnation of Christ your Son was made known by the message of an Angel, may, through the intercession of the Blessed Virgin Mary, by his Passion and Cross be brought to the glory of his Resurrection. Who lives and reigns with you in the unity of the Holy Spirit, one God, for ever and ever.
PRAYER OVER THE OFFERINGS
Grant, we pray, O Lord, that we may be rightly conformed to these offerings we bring and so honour the mysteries of your Only Begotten Son, as to be made worthy of his promises. Who lives and reigns for ever and ever.

PRAYER AFTER COMMUNION
We pray, O
Lord our God, that, just as we proclaim in this Sacrament the Death and
Resurrection of your Son, so, being made partakers in his suffering, we may
also merit a share in his consolation and his glory. Who lives and reigns for
ever and ever.


Probability of Functioning Water Pumps
Amount of water available:
400
Population around water pump:
4000
Altitude of water pump:
200


<subjectHead>
The <subjectHead>
element provides a heading for a group of subjects,
for use if the scheme is displayed. For instance, a scheme may be displayed to let a user
select subjects as part of faceted browsing. The <subjectHead>
element
itself does not reference a file and cannot be referenced as a key, so it does not define
any controlled values.
Category: Subject scheme elements


Compute changelog for this job. Default is 'true'.
true
If changelog is false, then the changelog will not be computed for this job. If changelog is true or is not set, then the changelog will be computed.
changelog


Forture Cookies
Forture Cookies
Username
Password
Sign in
Remember me
or Register
Sign out
Home
My Cookie
Sort by:
likes
shareDate


| Home |
If you find are experiencing a problem which cannot be resolved by following these suggestions then check out the Tuffcode Support FAQs or contact<EMAIL_ADDRESS>and we will do our best to help you.
Problem categories:
Requests missing from capture |
|---|
|
If you fail to see the HTTP requests you were expecting, first ensure that you have selected the appropriate network interface from the drop-down at the top-right of the main screen. Check also that you have not been too restrictive in the ports and hosts you have specified in Scoop Settings. Specifying a host name (as opposed to an IP address) in the Restrict to hosts list in Scoop Settings can cause confusion in a couple of situations. Firstly, the host name you type into a browser may be where the HTML is stored, but other resources such as images may be held on another server. Also, some sites use round-robin DNS for load balancing in which successive host lookups result in different IP addresses being resolved. In this case, the IP address which HTTP Scoop resolves a host name to - and hence filters traffic upon - could be different to the IP address being accessed by the client. |
"Reset by peer" request status |
|---|
|
This status message indicates that either the client or the server has forcibly closed the TCP connection over which an HTTP request was sent. This is carried out by setting the RST bit in a TCP header. You can verify this by examining the TCP flags shown in the TCP/IP tab. Connections may be reset for a variety of reasons. It may be set because an error has been detected in data received by the client or server, for example a timeout may have occurred or an invalid TCP header may have been received. The RST flag is also issued by some servers when they need to release resources quickly because of high loading. When a browser gets an unexpected connection reset from a web-server it will typically retry the HTTP request on a new TCP connection. Some browsers issue the RST flag rather than a graceful TCP close using a FIN handshake when a page load is cancelled because the browser window is being closed or the browser is being exited entirely. |
"Closed by peer" request status |
|---|
|
This status message indicates that the TCP connection over which the HTTP conversation is being conducted has been closed before the response was completely read. This could be due to a server or network error or because of congestion on the server. This message may also appear if some packets were lost - check for the "Traffic too fast: some packets lost" message. |
"Traffic too fast: some packets lost" shown in status bar |
|---|
|
This message appearing in the status bar at the top of the screen indicates that the Operating System discarded some packets because the CPU and/or network load has been too great. An HTTP client such as a browser does not suffer from this problem because it uses TCP to control the flow of data - only a certain amount of data will be sent from the server before an acknowledgement must be sent. In contract, a passive observer such as HTTP Scoop must be able to keep up with the flow of network traffic in order to be able to accurately reconstruct the conversation. The problem is more likely to arise in the following situations:
The best way to avoid this problem is to check your settings to ensure that you only monitor the appropriate TCP ports, only use promiscuous mode where necessary and restrict the capture to the required hosts. You should also minimise CPU activity from other applications. In extreme circumstances, you may find that it reduces CPU utilisation (and hence the reliability of the capture) to close the "HTTP Request Detail" window during periods of intense network activity. Note that after this warning has been shown, any attempt to save a response body will give a warning that the file may be corrupt due to missing packets. If the file was captured prior to packets being dropped and has a status of Done then the file's integrity should be intact. However the warning is designed to make you think twice - especially when saving executables - about whether any damage could result from the file being incorrectly recorded. To avoid the warning simply clear the list, reissue the request and attempt to capture the file again. |