Thank you for creating an account. A welcome email has been sent to you, please click the link in this email to complete the registration process.


Choose you experties!
{{ex}}
Choose your Sub Catagory!
{{sub}}
You have chosen : {{chosenSub}}!
Now choose the location (optional) :
And a time of your choice (optional) :
Are You Sure ?
Yes
No


Ice Storm dangerous but alive
Ice Storm A Film Review By Michael Redman Copyright 1997 By Michael Redman
***1/2 (out of ****)
There's something resplendent about a winter ice storm that few people ever experience as they huddle inside awaiting the thaw. Viewing from safety through the glazed glass gives a distorted view of the beauty and the danger outside in the extremes.
During the early seventies the suburbs were a questionable refuge from the whirlwind of change sweeping through the country. As the trappings of the cultural and sexual revolution became mainstream and seeped into those shelters, it happened without much of its soul. The exploration of the sixties turned into the "Me Decade" in a few short years.
In 1973 Ben Hood (Kevin Kline) is doing everything right. Married to a beautiful woman, he has a successful career, two kids and a modern house in the hamlet of New Canaan, Connecticut. It should be enough, but his life feels empty. His loveless affair with neighbor Janey Carver (Sigourney Weaver) isn't helping much. When he wants to talk, she responds "You're boring me. I have a husband. I don't have a need for another one."
Ben and Janey are indeed bored, not just with their spouses and each other, but with everything they do. Like the rest of their friends, they are grasping at straws searching for something to make them feel alive. They want to live on the edge from the comfort of their living rooms.
In direct contrast, the children are embracing life, fumbling though they may be. Paul Hood (Tobey Maguire) is away at boarding school and coming to grips with his own sexuality attempting to get the attention of an attractive girl before his Don Juan roommate gets to her first.
 There's a great scene where she's wearing a grotesque Nixon mask while Mikey lies on top of her in a basement family room. "Take down your pants and I'll touch it, but that's all," she tempts him. When Ben walks in on them after being abandoned in Janey's bed upstairs, it's a snapshot of seventies suburban life.
Painfully shy Duckie spends most of his time attaching M-80s to model planes and blowing them up in flight. His response to Wendy's propositions is fright. He's outgrown his toys but can't quite figure out what to do about it.
 The adults of the neighborhood attend a "key party" where the men put their car keys in a bowl and the women pick out a set to determine their partner for the night. While the joyless wife-swapping party takes place, an ice storm rages outside.
The kids head out to partake of the tempest while their parents nervously banter with each other. It's hazardous out there, but that's where life is. It's only by venturing into the unknown that anything meaningful happens as they will all discover. The only way to navigate the alien are with your eyes wide open -- something no one in the film does.
Surprisingly director Ang Lee ("Sense And Sensibility") does a good job representing the era since he didn't move to the US from Taiwan until 1978. As with many period pieces, there's a bit too many in-your-face artifacts. During the first half you'll grow tired of waterbeds, ugly hairstyles and those atrocious fashions, but they aren't shoved down your throat in the same manner that they were in "Boogie Nights".
Stepping out of the theater on a crisp winter's night with ice crunching beneath your feet, you'll realize that we are all slipping around out there in the wilderness in one way or another. About the most we can hope for is that we make it through with some measure of grace.
(Michael Redman has celebrated over 22 winter holiday seasons while writing these columns. He's still awaiting the Christmas spirit.)
[This appeared in the 12/18/97 "Bloomington Voice", Bloomington, Indiana. Michael Redman can be reached at<EMAIL_ADDRESS>]
--<EMAIL_ADDRESS>This week's film review at http://www.bvoice.com/ Film reviews archive at http://us.imdb.com/M/reviews_by?Michael%20Redman
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Dave Smith Instruments Prophet '08
Single Patch Editor
This editor will work with the Prophet '08 and Prophet '08 Desktop.
Communicating with Edisyn
Set the MIDI channel to the same as being used in Edisyn. Set MParamSend to NRPN. Set M Param Rec to All or NRPN. Set MIDI Program to ON. Set MIDI Sysex to ON. And set MIDIParamLCD to ON.
Hints
- When you set the destination for a sequencer track to "Osc 1 Freq", "Osc 2 Freq", or "Osc 1&2 Freq", the track dials will change from number values to notes. The lowest note, C0, corresponds to the note being played by the user -- that is, all sequenced notes are equal to or higher than the played note. If you need notes lower than the played note, pitch the oscillator frequencies down.
Gotchas
- Even if MIDIParamLCD is set to ON, any real-time changes you make won't be reflected on the Prophet '08 LCD unless you first twiddle a knob so the Prophet '08 is in its edit mode. I suggest twiddling the Misc Parameters Select knob.
- Additionally, even if MIDIParamLCD is on, and the Prophet '08 is displaying parameter edits, you won't see parameter changes from Layer B unless you press "Edit Layer B".
- If you change Key Sync for some LFO other than #1, the Key Sync light won't change properly, even if that LFO is currently selected on the Prophet '08 front panel. You have to press some other LFO button, then go back to the LFO in question to see the Key Sync button light properly.
| By
| Sean Luke
|
| Date
| June 2018
|


{% extends 'comm/emails/base.html' -%}
{% block content %}
Dear Superheroes,
A developer has uploaded/resubmitted an {{ obj_type }} we've designated to be super important and/or a massive PITA.
Please roll out the red carpet, don your white/rubber gloves and give the following {{ obj_type }} your attention in due time.
{% include 'comm/emails/includes/details.html' %}
{% endblock %}


le_temp_interface.h File Reference
#include "legato.h"
Go to the source code of this file.
Typedefs | |
| typedef struct le_temp_ThresholdEventHandler * | le_temp_ThresholdEventHandlerRef_t |
| typedef void(* | le_temp_ThresholdEventHandlerFunc_t) (le_temp_ThresholdStatus_t event, void *contextPtr) |
Functions | |
| void | le_temp_ConnectService (void) |
| void | le_temp_DisconnectService (void) |
| le_temp_ThresholdEventHandlerRef_t | le_temp_AddThresholdEventHandler (le_temp_ThresholdEventHandlerFunc_t handlerPtr, void *contextPtr) |
| void | le_temp_RemoveThresholdEventHandler (le_temp_ThresholdEventHandlerRef_t addHandlerRef) |
| le_result_t | le_temp_GetPlatformTemperature (int32_t *platformTempPtr) |
| le_result_t | le_temp_GetRadioTemperature (int32_t *radioTempPtr) |
| le_result_t | le_temp_SetPlatformThresholds (int32_t lowCriticalTemp, int32_t lowWarningTemp, int32_t hiWarningTemp, int32_t hiCriticalTemp) |
| le_result_t | le_temp_GetPlatformThresholds (int32_t *lowCriticalTempPtr, int32_t *lowWarningTempPtr, int32_t *hiWarningTempPtr, int32_t *hiCriticalTempPtr) |
| le_result_t | le_temp_SetRadioThresholds (int32_t hiWarningTemp, int32_t hiCriticalTemp) |
| le_result_t | le_temp_GetRadioThresholds (int32_t *hiWarningTempPtr, int32_t *hiCriticalTempPtr) |
Detailed Description
Legato Temperature Monitoring include file.
Copyright (C) Sierra Wireless Inc. Use of this work is subject to license.
Typedef Documentation
| typedef void(* le_temp_ThresholdEventHandlerFunc_t) (le_temp_ThresholdStatus_t event, void *contextPtr) |
Handler for Temperature event.
- Parameters
-
event Temperature threshold event reached. contextPtr
| typedef struct le_temp_ThresholdEventHandler* le_temp_ThresholdEventHandlerRef_t |
Reference type used by Add/Remove functions for EVENT 'le_temp_ThresholdEvent'
Enumeration Type Documentation
Temperature event type.
Function Documentation
| le_temp_ThresholdEventHandlerRef_t le_temp_AddThresholdEventHandler | ( | le_temp_ThresholdEventHandlerFunc_t | handlerPtr, |
| void * | contextPtr | ||
| ) |
Add handler function for EVENT 'le_temp_ThresholdEvent'
This event provides information on Threshold reached.
- Parameters
-
[in] handlerPtr [in] contextPtr
| void le_temp_ConnectService | ( | void | ) |
Connect the current client thread to the service providing this API.
This function must be called before any other functions in this API. Normally, it's automatically called for the main thread, but must be explicitly called for other threads. For details, see Client-specific Functions.
This function is created automatically.
| void le_temp_DisconnectService | ( | void | ) |
Disconnect the current client thread from the service providing this API.
Normally, this function doesn't need to be called. After this function is called, there's no longer a connection to the service, and the functions in this API can't be used. For details, see Client-specific Functions.
This function is created automatically.
| le_result_t le_temp_GetPlatformTemperature | ( | int32_t * | platformTempPtr | ) |
Get the Platform temperature level in degree celsius.
- Returns
- LE_OK The function succeeded.
- LE_FAULT The function failed to get the temperature.
- Parameters
-
[out] platformTempPtr [OUT] The Platform temperature level in degree celsius.
| le_result_t le_temp_GetPlatformThresholds | ( | int32_t * | lowCriticalTempPtr, |
| int32_t * | lowWarningTempPtr, | ||
| int32_t * | hiWarningTempPtr, | ||
| int32_t * | hiCriticalTempPtr | ||
| ) |
Get the Platform warning and critical temperature thresholds in degree celsius.
- Returns
- LE_OK The function succeeded.
- LE_FAULT The function failed to get the thresholds.
- Parameters
-
[out] lowCriticalTempPtr [OUT] The low critical temperature threshold in degree celsius. [out] lowWarningTempPtr [OUT] The low warning temperature threshold in degree celsius. [out] hiWarningTempPtr [OUT] The high warning temperature threshold in degree celsius. [out] hiCriticalTempPtr [OUT] The high critical temperature threshold in degree celsius.
| le_result_t le_temp_GetRadioTemperature | ( | int32_t * | radioTempPtr | ) |
Get the Radio temperature level in degree celsius.
- Returns
- LE_OK The function succeeded.
- LE_FAULT The function failed to get the temperature.
- Parameters
-
[out] radioTempPtr [OUT] The Radio temperature level in degree celsius.
| le_result_t le_temp_GetRadioThresholds | ( | int32_t * | hiWarningTempPtr, |
| int32_t * | hiCriticalTempPtr | ||
| ) |
Get the Radio warning and critical temperature thresholds in degree celsius.
- Returns
- LE_OK The function succeeded.
- LE_FAULT The function failed to get the thresholds.
- Parameters
-
[out] hiWarningTempPtr [OUT] The high warning temperature threshold in degree celsius. [out] hiCriticalTempPtr [OUT] The high critical temperature threshold in degree celsius.
| void le_temp_RemoveThresholdEventHandler | ( | le_temp_ThresholdEventHandlerRef_t | addHandlerRef | ) |
Remove handler function for EVENT 'le_temp_ThresholdEvent'
- Parameters
-
[in] addHandlerRef
| le_result_t le_temp_SetPlatformThresholds | ( | int32_t | lowCriticalTemp, |
| int32_t | lowWarningTemp, | ||
| int32_t | hiWarningTemp, | ||
| int32_t | hiCriticalTemp | ||
| ) |
Set the Platform warning and critical temperature thresholds in degree celsius. When thresholds temperature are reached, a temperature event is triggered.
- Returns
- LE_OK The function succeeded.
- LE_BAD_PARAMETER The hiWarning threshold + 1 is equal to or higher than the hiCritical threshold. The loWwarning threshold is equal to or higher than the hiWarning threshold. The loWwarning threshold is equal to or lower than the loCritical threshold.
- LE_FAULT The function failed to set the thresholds.
- Parameters
-
[in] lowCriticalTemp [IN] The low critical temperature threshold in degree celsius. [in] lowWarningTemp [IN] The low warning temperature threshold in degree celsius. [in] hiWarningTemp [IN] The high warning temperature threshold in degree celsius. [in] hiCriticalTemp [IN] The high critical temperature threshold in degree celsius.
| le_result_t le_temp_SetRadioThresholds | ( | int32_t | hiWarningTemp, |
| int32_t | hiCriticalTemp | ||
| ) |
Set the Radio warning and critical temperature thresholds in degree celsius. When thresholds temperature are reached, a temperature event is triggered.
- Returns
- LE_OK The function succeeded.
- LE_BAD_PARAMETER The hiWarning threshold + 1 is equal to or higher than the hiCritical threshold.
- LE_FAULT The function failed to set the thresholds.
- Parameters
-
[in] hiWarningTemp [IN] The high warning temperature threshold in degree celsius. [in] hiCriticalTemp [IN] The high critical temperature threshold in degree celsius.


@(siteSettings: utils.templates.SiteSettings)(implicit configuration: play.api.Configuration, environment: play.api.Environment) @if(utils.templates.TemplateSettings.show_solar_cal(siteSettings)){
By clicking the submit button, you agree to our privacy policy and authorize Easier Solar and its network of service providers to contact you at the phone number you entered using automated technology including auto-dialers, pre-recorded messages, and text messages, even if your phone is a mobile number or is currently listed on any state, federal, or corporate "Do Not Call" lists, and you are not required to give your consent as a condition of service.


Welcome
The Flips Project is a program that began with a mission to make the joy of Gymnastics accessible to financially challenged families in Central Oregon. Boys and girls ages 6-10 can bounce aound during a class one hour a week for an 8 week session at OOA Gymnastics. The class is taught by high school volunteers that have been involved in gymnastics themselves. Kids will get to learn balance, agility, and body awareness as well as fun tricks on Beam, Bars, Floor, and Tramp. Come join us for some fun, movement education, and beginning gymnastics!


A Timber program consists of a collection of modules. One of these is the root module and contains the root definition. The root definition must have a prescribed root type, that may depend on the target environment. A Timber installation may support several target environments/platforms.
The other modules in the program provide auxiliary definitions, used by the root module and by other auxiliary modules. The compilation unit in Timber is the module, so modules may be compiled individually (but see below for dependencies).
module moduleName where
importDeclaration*
topLevelDeclaration*
private
topLevelDeclaration*
Here, as in many places of Timber syntax, indentation is significant. The import and top-level declarations must be indented at least one step and be vertically aligned, i.e., the first character of each declaration must be in the same column. An exception is the (common) case where there is no private part; then indentation can be omitted (and all declarations start in the leftmost column).
A module has a simple name, which is an identifier starting with an upper-case letter. Modules are conventionally stored in files of the same name with suffix .t, i.e. module Dictionary is stored in Dictionary.t.
Projects and Timber sites may use hierarchical module names to allow multiple modules with the same name or to indicate structure e.g. in a library. Thus, module Dictionary may need to be referred to by clients as e.g. Data.Object.Dictionary; it is up to the implementation whether this module is stored in Data.Object.Dictionary.t or in Data/Object/Dictionary.t relative to some installation-dependent notion of search paths. Module hierarchies in Timber have no other significance than to support organizing and subsequently finding modules in a file system.
The module name is given in the header, as described above.
A module may depend on other modules, i.e. use types or values defined in these modules. In a Timber program the dependency graph between modules must be acyclic; no recursive dependencies are allowed. This means that modules can be compiled in dependency order: when a certain module is compiled, all the modules it depends on have already been compiled. A compiler option can make the compiler decide on recompilation order after a system has been changed.
Following the header is a sequence of import/use declarations, i.e. declaration of the modules that the current module depends on. There are two forms of such declarations:
Both forms of declaration give access to all exported entities from the named module; the difference is that in the latter case one must use the qualified name of an imported entity, while in the former case the simple (unqualified) name is enough, unless name clashes occur.
Name clashes are handled as follows:
All the entities (types, defaults and values) defined in the sequence of public top-level declarations are exported, i.e. can be referred to by importing/using modules. Entities defined in the private part are not exported and hence not visible to importing/using modules. In particular, this means that the type environment of the public part must be closed, i.e. the type of an exported value must not mention a type defined in the private part. Imported entities are re-exported, i.e.the import relation is transitive: if module C imports B, which imports A, the entities in A are visible in C, even if C does not explicitly import A. If the only chain from module C to module A passes a "use" declaration, though, entities defined in A must be referred to in C by their qualified names.


Implementation of a Bayesian approach for estimating a mixture of gamma distributions in which the mixing occurs over the shape parameter. This family provides a flexible and novel approach for modeling heavy-tailed distributions, it is computationally efficient, and it only requires to specify a prior distribution for a single parameter.
| Version: | 1.3.2 |
| Depends: | gtools, methods, utils |
| Imports: | graphics, grDevices, stats |
| Published: | 2015-07-08 |
| Author: | Sergio Venturini |
| Maintainer: | Sergio Venturini <sergio.venturini at unibocconi.it> |
| License: | GPL-2 | GPL-3 [expanded from: GPL (≥ 2)] |
| URL: | http://projecteuclid.org/euclid.aoas/1215118537 |
| NeedsCompilation: | no |
| In views: | Cluster, Distributions |
| CRAN checks: | GSM results |
| Reference manual: | GSM.pdf |
| Package source: | GSM_1.3.2.tar.gz |
| Windows binaries: | r-devel: GSM_1.3.2.zip, r-release: GSM_1.3.2.zip, r-oldrel: GSM_1.3.2.zip |
| OS X binaries: | r-release: GSM_1.3.2.tgz, r-oldrel: GSM_1.3.2.tgz |
| Old sources: | GSM archive |
| Reverse suggests: | fitteR |
Please use the canonical form https://CRAN.R-project.org/package=GSM to link to this page.


Add New Album
title:
artist:
count:
length:
url:
album:
artist:
number of songs:
length in seconds:
Show Album


A B C D E F G I L M N O P R S T U W misc
| absoluteRanges | Transform genomic ranges into "absolute" ranges |
| as.character-method | GRanges objects |
| as.data.frame-method | Memory-efficient representation of genomic positions |
| as.data.frame-method | GRanges objects |
| as.data.frame.GPos | Memory-efficient representation of genomic positions |
| as.factor-method | GRanges objects |
| bindAsGRanges | Manipulating genomic variables |
| bindROWS-method | GRanges objects |
| binnedAverage | Manipulating genomic variables |
| checkConstraint | Enforcing constraints thru Constraint objects |
| class:CompressedGenomicRangesList | GenomicRangesList objects |
| class:CompressedGRangesList | GRangesList objects |
| class:Constraint | Enforcing constraints thru Constraint objects |
| class:Constraint_OR_NULL | Enforcing constraints thru Constraint objects |
| class:DelegatingGenomicRanges | DelegatingGenomicRanges objects |
| class:GenomicPos | GRanges objects |
| class:GenomicRanges | GRanges objects |
| class:GenomicRangesList | GenomicRangesList objects |
| class:GenomicRanges_OR_GenomicRangesList | GenomicRangesList objects |
| class:GenomicRanges_OR_GRangesList | GRangesList objects |
| class:GNCList | GNCList objects |
| class:GPos | Memory-efficient representation of genomic positions |
| class:GRanges | GRanges objects |
| class:GRangesFactor | GRangesFactor objects |
| class:GRangesList | GRangesList objects |
| class:IRanges_OR_IPos | GRanges objects |
| class:SimpleGenomicRangesList | GenomicRangesList objects |
| class:SimpleGRangesList | GRangesList objects |
| class:StitchedGPos | Memory-efficient representation of genomic positions |
| class:UnstitchedGPos | Memory-efficient representation of genomic positions |
| coerce-method | GNCList objects |
| coerce-method | Memory-efficient representation of genomic positions |
| coerce-method | GRanges objects |
| coerce-method | GRangesFactor objects |
| coerce-method | GRangesList objects |
| coerce-method | Manipulating genomic variables |
| coerce-method | Make a GRanges object from a data.frame or DataFrame |
| CompressedGenomicRangesList | GenomicRangesList objects |
| CompressedGenomicRangesList-class | GenomicRangesList objects |
| CompressedGRangesList | GRangesList objects |
| CompressedGRangesList-class | GRangesList objects |
| Constraint | Enforcing constraints thru Constraint objects |
| constraint | Enforcing constraints thru Constraint objects |
| Constraint-class | Enforcing constraints thru Constraint objects |
| constraint<- | Enforcing constraints thru Constraint objects |
| Constraints | Enforcing constraints thru Constraint objects |
| Constraint_OR_NULL | Enforcing constraints thru Constraint objects |
| Constraint_OR_NULL-class | Enforcing constraints thru Constraint objects |
| countOverlaps | Finding overlapping genomic ranges |
| countOverlaps-method | Finding overlapping genomic ranges |
| coverage | Coverage of a GRanges or GRangesList object |
| coverage-method | Coverage of a GRanges or GRangesList object |
| coverage-methods | Coverage of a GRanges or GRangesList object |
| DelegatingGenomicRanges-class | DelegatingGenomicRanges objects |
| disjoin | Inter range transformations of a GRanges or GRangesList object |
| disjoin-method | Inter range transformations of a GRanges or GRangesList object |
| disjointBins | Inter range transformations of a GRanges or GRangesList object |
| disjointBins-method | Inter range transformations of a GRanges or GRangesList object |
| distance | Finding the nearest genomic range/position neighbor |
| distance-method | Finding the nearest genomic range/position neighbor |
| distanceToNearest | Finding the nearest genomic range/position neighbor |
| distanceToNearest-method | Finding the nearest genomic range/position neighbor |
| duplicated-method | Comparing and ordering genomic ranges |
| duplicated.GenomicRanges | Comparing and ordering genomic ranges |
| elementMetadata-method | GenomicRangesList objects |
| elementMetadata<--method | GenomicRangesList objects |
| end-method | GNCList objects |
| end-method | GRangesFactor objects |
| end<--method | GRanges objects |
| end<--method | GenomicRangesList objects |
| extractROWS-method | GenomicRangesList objects |
| FactorToClass-method | GRangesFactor objects |
| findOverlaps | Finding overlapping genomic ranges |
| findOverlaps-method | Finding overlapping genomic ranges |
| findOverlaps-methods | Finding overlapping genomic ranges |
| flank | Intra range transformations of a GRanges or GRangesList object |
| flank-method | Intra range transformations of a GRanges or GRangesList object |
| follow | Finding the nearest genomic range/position neighbor |
| follow-method | Finding the nearest genomic range/position neighbor |
| from_GPos_to_GRanges | Memory-efficient representation of genomic positions |
| gaps | Inter range transformations of a GRanges or GRangesList object |
| gaps-method | Inter range transformations of a GRanges or GRangesList object |
| genomic-range-squeezers | Squeeze the genomic ranges out of a range-based object |
| GenomicPos | GRanges objects |
| GenomicPos-class | GRanges objects |
| GenomicRanges | GRanges objects |
| GenomicRanges-class | GRanges objects |
| GenomicRanges-comparison | Comparing and ordering genomic ranges |
| GenomicRangesList | GenomicRangesList objects |
| GenomicRangesList-class | GenomicRangesList objects |
| GenomicRanges_OR_GenomicRangesList | GenomicRangesList objects |
| GenomicRanges_OR_GenomicRangesList-class | GenomicRangesList objects |
| GenomicRanges_OR_GRangesList | GRangesList objects |
| GenomicRanges_OR_GRangesList-class | GRangesList objects |
| GenomicRanges_OR_missing-class | GRanges objects |
| genomicvariables | Manipulating genomic variables |
| genomicvars | Manipulating genomic variables |
| getListElement-method | GRanges objects |
| getListElement-method | GenomicRangesList objects |
| GNCList | GNCList objects |
| GNCList-class | GNCList objects |
| GPos | Memory-efficient representation of genomic positions |
| GPos-class | Memory-efficient representation of genomic positions |
| GRanges | GRanges objects |
| granges | Squeeze the genomic ranges out of a range-based object |
| GRanges-class | GRanges objects |
| granges-method | GNCList objects |
| granges-method | GRanges objects |
| granges-method | GRangesFactor objects |
| GRangesFactor | GRangesFactor objects |
| GRangesFactor-class | GRangesFactor objects |
| GRangesList | GRangesList objects |
| GRangesList-class | GRangesList objects |
| grglist | Squeeze the genomic ranges out of a range-based object |
| grglist-method | Squeeze the genomic ranges out of a range-based object |
| inter-range-methods | Inter range transformations of a GRanges or GRangesList object |
| intersect | Set operations on genomic ranges |
| intersect-method | Set operations on genomic ranges |
| intra-range-methods | Intra range transformations of a GRanges or GRangesList object |
| invertStrand-method | Strand utilities |
| IRanges_OR_IPos | GRanges objects |
| IRanges_OR_IPos-class | GRanges objects |
| is.unsorted-method | Comparing and ordering genomic ranges |
| isDisjoint | Inter range transformations of a GRanges or GRangesList object |
| isDisjoint-method | Inter range transformations of a GRanges or GRangesList object |
| isSmallGenome | Transform genomic ranges into "absolute" ranges |
| length-method | GNCList objects |
| length-method | GRanges objects |
| length-method | GenomicRangesList objects |
| makeGRangesFromDataFrame | Make a GRanges object from a data.frame or DataFrame |
| makeGRangesListFromDataFrame | Make a GRangesList object from a data.frame or DataFrame |
| makeGRangesListFromFeatureFragments | GRangesList objects |
| match-method | Comparing and ordering genomic ranges |
| mcolAsRleList | Manipulating genomic variables |
| names-method | GNCList objects |
| names-method | GRanges objects |
| names-method | GenomicRangesList objects |
| names<--method | GRanges objects |
| names<--method | GenomicRangesList objects |
| narrow-method | Intra range transformations of a GRanges or GRangesList object |
| nearest | Finding the nearest genomic range/position neighbor |
| nearest-method | Finding the nearest genomic range/position neighbor |
| nearest-methods | Finding the nearest genomic range/position neighbor |
| order-method | Comparing and ordering genomic ranges |
| overlapsAny | Finding overlapping genomic ranges |
| parallelSlotNames-method | GRanges objects |
| pcompare | Comparing and ordering genomic ranges |
| pcompare-method | Comparing and ordering genomic ranges |
| pgap | Set operations on genomic ranges |
| pgap-method | Set operations on genomic ranges |
| phicoef | Calculate the "phi coefficient" between two binary variables |
| pintersect | Set operations on genomic ranges |
| pintersect-method | Set operations on genomic ranges |
| pos-method | Memory-efficient representation of genomic positions |
| pos-method | GRangesFactor objects |
| precede | Finding the nearest genomic range/position neighbor |
| precede-method | Finding the nearest genomic range/position neighbor |
| promoters | Intra range transformations of a GRanges or GRangesList object |
| promoters-method | Intra range transformations of a GRanges or GRangesList object |
| psetdiff | Set operations on genomic ranges |
| psetdiff-method | Set operations on genomic ranges |
| punion | Set operations on genomic ranges |
| punion-method | Set operations on genomic ranges |
| range | Inter range transformations of a GRanges or GRangesList object |
| range-method | Inter range transformations of a GRanges or GRangesList object |
| ranges-method | DelegatingGenomicRanges objects |
| ranges-method | GNCList objects |
| ranges-method | GRanges objects |
| ranges-method | GRangesFactor objects |
| ranges-method | GRangesList objects |
| ranges<--method | GRanges objects |
| ranges<--method | GRangesList objects |
| rank-method | Comparing and ordering genomic ranges |
| reduce | Inter range transformations of a GRanges or GRangesList object |
| reduce-method | Inter range transformations of a GRanges or GRangesList object |
| relativeRanges | Transform genomic ranges into "absolute" ranges |
| relistToClass-method | GRangesList objects |
| resize | Intra range transformations of a GRanges or GRangesList object |
| resize-method | Intra range transformations of a GRanges or GRangesList object |
| restrict | Intra range transformations of a GRanges or GRangesList object |
| restrict-method | Intra range transformations of a GRanges or GRangesList object |
| score-method | GRanges objects |
| score-method | GenomicRangesList objects |
| score<--method | GRanges objects |
| score<--method | GenomicRangesList objects |
| selfmatch-method | Comparing and ordering genomic ranges |
| seqinfo-method | DelegatingGenomicRanges objects |
| seqinfo-method | GNCList objects |
| seqinfo-method | GRanges objects |
| seqinfo-method | GRangesFactor objects |
| seqinfo-method | GenomicRangesList objects |
| seqinfo<--method | GRanges objects |
| seqinfo<--method | GenomicRangesList objects |
| seqnames-method | DelegatingGenomicRanges objects |
| seqnames-method | GNCList objects |
| seqnames-method | GRanges objects |
| seqnames-method | GRangesFactor objects |
| seqnames-method | GenomicRangesList objects |
| seqnames<--method | GRanges objects |
| seqnames<--method | GenomicRangesList objects |
| setdiff | Set operations on genomic ranges |
| setdiff-method | Set operations on genomic ranges |
| setops-methods | Set operations on genomic ranges |
| shift-method | Intra range transformations of a GRanges or GRangesList object |
| show-method | Memory-efficient representation of genomic positions |
| show-method | GRanges objects |
| show-method | GRangesFactor objects |
| show-method | GenomicRangesList objects |
| SimpleGenomicRangesList | GenomicRangesList objects |
| SimpleGenomicRangesList-class | GenomicRangesList objects |
| SimpleGRangesList | GRangesList objects |
| SimpleGRangesList-class | GRangesList objects |
| slidingWindows | Generate windows for a GenomicRanges |
| slidingWindows-method | Generate windows for a GenomicRanges |
| sort-method | Comparing and ordering genomic ranges |
| sort.GenomicRanges | Comparing and ordering genomic ranges |
| start-method | GNCList objects |
| start-method | GRanges objects |
| start-method | GRangesFactor objects |
| start<--method | GRanges objects |
| start<--method | GenomicRangesList objects |
| StitchedGPos | Memory-efficient representation of genomic positions |
| StitchedGPos-class | Memory-efficient representation of genomic positions |
| strand-method | DelegatingGenomicRanges objects |
| strand-method | GNCList objects |
| strand-method | GRanges objects |
| strand-method | GRangesFactor objects |
| strand-method | GenomicRangesList objects |
| strand-method | Strand utilities |
| strand-utils | Strand utilities |
| strand<--method | GRanges objects |
| strand<--method | GenomicRangesList objects |
| strand<--method | Strand utilities |
| subsetByOverlaps | Finding overlapping genomic ranges |
| summary-method | GRanges objects |
| summary.GenomicRanges | GRanges objects |
| tile | Generate windows for a GenomicRanges |
| tile-method | Generate windows for a GenomicRanges |
| tile-methods | Generate windows for a GenomicRanges |
| tileGenome | Put (virtual) tiles on a given genome |
| trim | Intra range transformations of a GRanges or GRangesList object |
| trim-method | Intra range transformations of a GRanges or GRangesList object |
| union | Set operations on genomic ranges |
| union-method | Set operations on genomic ranges |
| unlist-method | GenomicRangesList objects |
| UnstitchedGPos | Memory-efficient representation of genomic positions |
| UnstitchedGPos-class | Memory-efficient representation of genomic positions |
| update-method | GRanges objects |
| updateObject-method | Memory-efficient representation of genomic positions |
| updateObject-method | GRanges objects |
| updateObject-method | GenomicRangesList objects |
| update_ranges-method | Intra range transformations of a GRanges or GRangesList object |
| width-method | GNCList objects |
| width-method | GRanges objects |
| width-method | GRangesFactor objects |
| width<--method | GRanges objects |
| width<--method | GenomicRangesList objects |
| $-method | GRanges objects |
| $<--method | GRanges objects |
| [-method | GRanges objects |
| [-method | GRangesList objects |
| [<--method | GRangesList objects |


{% extends "layout.html" %} {% block page_title %} GOV.UK prototyping kit {% endblock %} {% block content %} ALPHA This is a new service – your feedback will help us to improve it. What type of waste did you transfer? Wastes from agriculture, horticulture, aquaculture, forestry, hunting and fishing Sludges from washing and cleaning Animal-tissue waste Plant-tissue waste Waste plastics (except packaging) Animal faeces, urine and manure (including spoiled straw), effluent, collected separately and treated off-site Wastes from forestry Agrochemical waste containing dangerous substances Agrochemical waste other than those mentioned in 02 01 08 Waste metal Wastes not otherwise specified {% endblock %}
ALPHA This is a new service – your feedback will help us to improve it.


This project renders 3D geometry as silhouetted wireframe in real-time with a movable camera. The edges are to be rendered to look like they were created by a vector monitor. I was the sole developer of this project and used OpenGL and SDL to handle graphics and windowing. An example screeshot can be seen below.
The rest of this page is mostly a development blog. The final description, a video demo, and screenshots are found at the end. Click the button in "Jump to post" to skip to these sections.
Hello and welcome to my development blog for the final project of Computer Graphics and Interaction (DH2323). In the following posts, I will detail the development process behind the creation of the project.
The goal of the project is to create and document something related to the objectives of the class. This is very open ended giving me a wide array of topics to choose from. As of now, I am not entirely sure what I want to do, but I have a couple ideas that I want to play around with before settling of a project specification.
Before I can work on a prototype for the project, I first needed do some setup. Since we have used SDL for the labs, I choose to use it to handle window creation and input. However, I decided to use the more updated SDL 2 instead of SDL 1 we used in the labs. To help me learn SDL and setup the prototype I used Lazy Foo' Productions SDL Tutorials. For rendering graphics I choose to use OpenGL. Again, as I do not have a lot of experience with OpenGL I setup my environment with the help of an OpenGL tutorial.
For the sake of getting a prototype up and running, I have copied some of the code from these two tutorials into Visual Studios and after some debugging, I was able to write a working framework for my prototype. Currently, it is able to load and render textured OBJ files with shading. I have also implemented rudimentary movement controls for the camera. A screenshot is displayed below.
Once I get a better idea of what I want to do with project, I will refactor the code to get rid of all the global variables and so that the code is completely my own. But first, now that I have something working to talk about, I am setting up this blog. For my next post, I plan to experiment with the shaders and hopefully develop an interesting prototype.
I have started work on making a prototype. The goal of the prototype is to make a wireframe shader that emulates vector monitors. Vector monitors are an old display technology where graphics are rendered via drawing lines as opposed to a grid of pixels as on raster monitors. These monitors where occasionally used in arcade games up until the mid 1980s. These games include Asteroids, Tempest, Star Wars, and Battlezone as pictured here.
The first method I tried was to use glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
. It is not a shader in itself, but a rendering option in OpenGL. However, as seen here this makes very thin aliased lines.
Quick update here. I have been spending a little time refactoring the code. I abstracted some of the code into several classes so that it will be easier to work with. Additionally, I didn't like how the outer edges of the wireframe were aliased in the previous post. This led to me looking into bloom and finding a tutorial on it. I also looked at other OpenGL topics in the tutorial which helped clean up the code even more.
I have completed a submitted the first draft of my project specification. As such, I have committed to project goal. Following is the current version of the specification.
The goal of the project is to render 3D geometry as silhouetted wireframe. The silhouette effect is where only the outer edges of the mesh are drawn in addition a couple other lines that distinguish model features.  With this project, I am aiming for an A or B grade.
There are two key components to this project: the silhouette effect and vector monitor lines. My inspiration for the silhouette effect comes from a PlayStation game called Vib-Ribbon [1]. Although Vib-Ribbon only approximates this effect using at geometry instead of a specially rendered model. A more modern example released during the development of this project is Muffled Warfare [2], which perfectly demonstrates the effect.
The second component is to emulate the look of vector monitors. Vector monitors are an old display technology where graphics are rendered via an electron beam directly drawing lines as opposed to a grid of pixels as on raster monitors. These monitors where occasionally used in arcade games up until the mid 1980s including Asteroids, Tempest, Star Wars [3], and Battlezone [4]. As there are not pixels the output is fairly striking due to the lack of aliasing, especially when compared to contemporary display technologies.
For this project I will be using SDL 2 to handle window creation and input, and for rendering graphics I will use OpenGL. The silhouette effect will be accomplished by detecting outline edges in the geometry shader which will then emit quads. The process is similar to an article I found on Silhouette Extraction [5]. Then the fragment shader will then render these lines to emulate the look of a vector monitor. I would also like to experiment with using bloom to create an even greater glowing effect.
Some potential challenges include obtaining and loading models, and figuring out how to detect lines that distinguish the model's features. To help with loading models I could use a library like Assimp. However, the method described above requires adjacency information which means that I will have to extend any model loading routine I find. Additionally, I will have to find models that are conducive to the silhouette effect without becoming a shapeless blob. This might be mitigated if I find a decent algorithm to detect distinguishing edges.
The development process will be documented in a blog which can be found here: https://bbernardoni.com/DGIProject/
As the goal of this project is to create convincing representations for 3D geometry under the restrictions of a vector monitor style display, the perceptual study should evaluate the success of the goal. This can be done by letting participants inspect the model and then surveying them about the quality of the rendering effect.
[1] Vib-Ribbon. PlayStation, NanaOn-Sha, 1999. Video Demonstration: https://www.youtube.com/watch?v=HhYa1WyeVsE
[2] Muffled Warfare. PC, Gattai Games, 2018. https://www.muffledwarfare.com/
[3] Star Wars. Arcade, Atari, 1983. Video Demonstration: https://www.youtube.com/watch?v=CbqFawQvdGE
[4] Battlezone. Arcade, Atari, 1980. Video Demonstration: https://www.youtube.com/watch?v=zdfKy4c7yuc&t=8m15s
[5] Rideout, Philip. "Silhouette Extraction" The Little Grasshoper. 24 October 2010. [Online]. Available: http://prideout.net/blog/?p=54.
Since the last update I have successfully implemented a prototype for the silhouette effect. This was accomplished by modifying the shaders given here. I started by extended the model loading algorithm to generate adjacency information. This is needed by the geometry shader to detect if an edge is an outline edge. The geometry shader was then adapted from the source above. As my code uses the perspective projection, the code had to be modified to account for the perspective divide.
There are several problems with the current implementation. First, to quickly code the model loading extension I used a naive algorithm that has a runtime of O(|V|²) where |V| is the number of vertices. For a simple model of 511 vertices running on my modest laptop, this takes about 4 seconds. I am fairly confident this can be reduced with a better algorithm. Another problem is that the model does not have a closed mesh so not all triangles have three adjacent triangles. Also, as the triangles are not filled in, the depth buffer cannot properly occlude lines behind the model. Finally, There are small gaps where two lines meet.
My goal this week was to try to use a new model with a closed mesh and to write a better adjacency generation algorithm.
First, I searched the Internet for a new model. I eventually found one that I liked. However, there was a problem. The model used a different file format than my previous model. To fixed this, I decided it was time to use a real model loading library. For this I choose to use Assimp. After building from source and some debugging, I got Assimp to load the old model. But, I encountered a problem when loading the new one. Once I got the model scaled correctly, I could not seem to get the silhouette algorithm to work properly. Even while rendering normally for debugging, the backface culling did not seem to be working. Eventually I discovered that for each outward facing triangle, the model contained a matching inward facing triangle. Hence why backface culling did not work. I did not want to deal with figuring out to deal with this, so instead I found another model.
While debugging the problems with the new models, I also worked on improving the adjacency generation algorithm. In the previous update I used a naive method that took 4 seconds to process the old model. I found a rather simple algorithm that uses a hashtable to generate the adjacency data in O(|V|). This is much faster and only took 100 milliseconds on my laptop, 40 times faster.
With these two changes I was able to generate the image displayed here. Nevertheless, there are still two problems that I discussed in the last post. The silhouettes are not being properly occlude and there are small gaps where two lines meet.
The main object of this update was to get occlusion working for the lines that are supposed to be hidden. The Silhouette Extraction article linked on the May 11th update gives a simple way of doing this. The "Spine Test" referenced was adapted from the paper Two Fast Methods for High-Quality Line Visibility. The process involves rendering the depth buffer of the mesh to a texture and then depth test along the spine of the line using the texture. After a little debugging, the result is mostly what I was looking for.
The other feature I wanted to add was crease lines. These lines are meant to distinguish where the model has hard edges. To implement this, I simply had to find the angle between normals of the triangles on either side of the edge. If these normals are more than 60 degrees apart, the line will be visible if it is not occluded.
Finally, I fixed the gap issue previous described by adding endcaps to the edges.
After adding these three features, I am getting closer to the intended visualization. The things that are still missing are more faded lines, experimenting with bloom, and possibly creating a better scene. However, as I mentioned before there are two flaws with the current implementation. First, there should really be lines where two meshes intersect. This can be seen where the bottom of the hand meets the wrist in this image. The solution unfortunately is outside the scope of this project as it would require advanced intersection tests to efficiently calculate the intersection paths of the meshes. Second, there are some issues with broken lines which is noticeable in the elbow joint of the picture. This occurs because of issues with Z-fighting in the depth buffer. I have already employed a couple tricks to reduce the frequency of the artifacts but I cannot find any further improvements.
Now that most of the correct lines are being properly selected, it is now time to turn my attention to the appearance of the rendered lines. To make the vector lines I simply made the lines bigger and then improved the fragment shader. Now the fragment shader colors each fragment as inversely proportional to the distance to the spine of the line. This effect can be seen in the left half of the image.
Next, I experimented with bloom. I had run some tests earlier, so it was not much work to reenable it. The result is shown in the right half of the image. In the end I decided that bloom does not really add anything and instead just makes the image blurrier. After all the fragment shader accomplishes the same effect of glowing lines, so bloom is just redundant.
I also slightly improved the depth testing since the last update. The new method was inspired by the source code of the Two Fast Methods paper. The actually implementation is quite different but the concepts are the same. There still are issues with Z-fighting but they are slightly reduced.
I forgot to mention this in the project specification but another target of this project was to have the algorithm run in real-time. Running on my relatively lower powered laptop with integrated graphics, the algorithm takes 1.134 milliseconds per frame to render the model in the image. Even if the scene is more complex with many more lines, the algorithm still should be able to run fairly smoothly in real-time.
At this point, my code is mostly complete. It can use some cleaning and refactoring, but it is feature complete. As such I will be focusing on writing the report.
Today is the day that the project is due. As such this will be a short update, so I can get back to finishing the report. While, reviewing the related works I noticed a section about z-biasing. I had tried using this to fix the z-fighting problem before but I could not get it to work properly. It seemed to work close up but didn't occlude anything when far away. Well, I realized that I had tried applying the bias by a constant amount in screen space and clip space but not view space where it should have been. So, after a quick hack, I got z-biasing working properly. There still are some occasional graphical artifacts, but for the most part they were gone. My suspicion is that the last artifacts are due to inopportune edge placements in the model rather than z-fighting.
The final project has officially been turned in. A couple of days late, since I kept finding small improvements that led to uncovering subtle bugs that take hours of debugging to fix. But after a three days of crunch, it is complete and I can celebrate by taking the rest of the day off... at least after I finish this post. I suppose its fitting since its my birthday anyway.
A lot of things have changed since the last post. So I'll go through each item in turn and them wrap up this post with discussing the final submission.
Probably the most noticeable thing in the picture above is that I introduced a new model. It is a sci-fi themed hallway that I got from here. By introducing a bigger model I found several bugs which I will discuss in the upcoming sections. One simple bug was that I was not handling edges with only one bordering face properly. While generating adjacency data, if a triangle is found to not have an adjacent face on any side an new vertex will be added and its index will be given to complete the adjacency data. If multiple of these border edges are found they will reference the same vertex. Additionally, this vertex is detectable in the geometry shader since it has a very large x position value.
The first thing I noticed when loading the hallway is that the long floorboards start behaving weirdly when one half goes behind the camera. I eventually figured out that is was because the point behind the camera has a negative homogeneous w component which messed up later calculations for computing position offsets. To solve this I added a clipping algorithm to clip each edge. I implemented the Cohen-Sutherland algorithm clipping on the six standard homogeneous planes with the help of this article.
Even after adding clipping, the lines would still behave weirdly. After a long time of debugging, I determined that the some of the variables sent to the vector lines fragment shader were being interpolated incorrectly. This was fixed for one variable by passing the full homogeneous coordinate and performing the perspective divide in the fragment shader and fixed for the other by adding the noperspective
qualifier.
While I was trying to describe how I tried to add bloom and didn't like its effect in the report, I realized I had for got one simple step. After the image was blurred it is added to the original to form the final image. I also added an option to scale the blurred component by a fixed factor. However, a factor of 1 worked the best. After this change, the results were much better. A comparison can be seen in the image where on the left is an 8 pixel half-width rendering without bloom and the right is a 4 pixel half-width rendering with bloom. With bloom the lines seem much smoother and the glow effect is greater.
The only thing I did not like was how applying the Gaussian blur took much longer than the rest of the rendering loop. At first, to increase the blur strength a 9-tap blur was repeated four times. However, I later found out this is nearly equivalent to a 17-tap blur applied once. Then, even further improvement came from the algorithm presented in this article. This method takes advantage of the GPU's texture filtering by sampling between texels to calculate two weights at a time. Now, only one iteration of a 9-tap filter is needed to achieve the same results. In the end, adding bloom only takes 1.99 milliseconds per frame.
The final project submission includes the project report, project specification, code, binary executable, screenshots (all over this blog), and a video demonstration (see below). In the report I cover a lot of the same information found in this blog. Although there are a few additional things I'll discuss below.
A target of this project was to have the application function in real-time. We can analyze this by testing frame rate. Using my relatively lower powered laptop with integrated graphics, the algorithm runs at 241.0 frames per second to render two test model of 2956 (dummy) and 6595 (hallway) vertices seen in the image at the top of this post. This equates to 4.15 milliseconds per frame where 1.99 milliseconds come from the bloom step which is constant for a given screen resolution. Another timing test shows that one, two, and three dummies take 3.154, 3.294, and 3.457 milliseconds per frame (= 317.1, 303.5, and 289.2 fps) respectively to render. This suggests that the method scales linearly with scene complexity. Even with a more complex scene comprised of more lines, the algorithm still should be able to run smoothly in real-time especially with better hardware.
As part of this project, I needed to give a description of a potential perceptual study. As the goal of this project was to create convincing representations for 3D geometry, a perceptual study should evaluate the effectiveness of the vector line representations. One possible method would be to test participants on their ability to identify objects while varying the rendering algorithm. This would provide incite as to how recognizable vector line images are. More detail about the study design can be found in the report.
Also for the report, I proposed several possible extensions to this project. As the lines are constant width, a model that is far away will seem cramped like the model on the left side on this image. The model could be displayed more sparsely by selecting edges more restrictively.
The test models used for this project were conducive towards the application of the algorithm. However, other models will not have as many distinguishing lines. This could be solved by implementing some of the other lines described by Al-Rousan et al. Edges can also be drawn at lines of intersecting geometry as exhibited where the hand meets the wrist on the right side of the image. The solution unfortunately is outside the scope of this project as it would require advanced intersection tests to efficiently calculate the intersection paths of the meshes.
Since the edges are taken directly from the underlying models, curved lines appear jagged. A method for smoothing these paths like presented in Wang et al. could be applied.
For the most part the overdraw method hides the gaps between edges. But, at T-intersections of lines the overdrawn part will stick out as seen in the top of the wrist.
Finally, in the current implementation all the lines are pure white. Instead the scene could be made more interesting by varying color and brightness. Even basic shading would be possible.
Finally, I will close this post with the video demo and some screenshots.


A primary cause of complexity is that software vendors uncritically adopt almost any feature that users want. --Niklaus Wirth [ source]


Check out what others have to say about Quixotic Quarantine
❮
❯
"The standard, expected beats and tropes are hit, but what happens within those elements makes the film so powerful and so rewarding." ~The Abu Dhabi Times
It's an enormous achievement to crystallise two decades of both fighting and loving in 81 minutes, as Bradley never takes Rich's voice away to patronise or preach to the viewer about what we should care about."~Snoopy
Doopy"
"Quixotic Qaurantine is a thrill ride - a passionate, heartfelt story of fandom at its very best."~Mojo Jojo
Hawkins is the undoubted star though, both determined and fragile."~Tyrion Lannister
"Ava is a napping-on-the-couch movie through and through, with recognizable names and a sexy premise but no distinct personality."~Cerci Lannister
This is an emotional experience."~Daddy D
" If people are willing to keep watching The Argument until the 'script reading' scenes, it will be worth the wait, because those scenes redeem what could have been a completely annoying movie."~Khalesi
"I enjoyed spending time with these characters (or character) but just enough to recommend it. I did not love it"~Aunty Gormint


This track is produced as part of the ENCODE Transcriptome Project. Transcription of different RNA extracts from different sub-cellular localizations in different cell lines is compared in companion experiments using three different technologies: tiling arrays, RNA-seq using Solexa, and RNA-seq using SOLiD. The tiling array data are shown in this track. The Transfrags data are lifted over from the hg18 assembly. The Raw Transfrags are available for download only. Other views are available on the hg18 assembly.
To show only selected subtracks, uncheck the boxes next to the tracks that you wish to hide.
Cells were grown according to the approved ENCODE cell culture protocols. RNA molecules longer than 200 nt and present in RNA population isolated from different subcellular compartments (such as cytosol, nucleus, polysomes and others) were fractionated into polyA+ and polyA- fractions as described in these protocols. Each RNA fraction was converted into double-stranded cDNA using random hexamers, labeled and hybridized to a tiling 91-array set containing probes against the non-repetitive portion of the human genome tiled on average every 5 bp (center-to-center of each consecutive 25-mers).
All arrays were scaled to a median array intensity of 330. Within a sliding 61 bp window centered on each probe, an estimate of RNA abundance was found by calculating the median of all pairwise average PM-MM values, where PM is a perfect match and MM is a mismatch. Kapranov et al. (2002), Cheng et al. (2005) , Kapranov et al. (2007), and Cawley et al. (2004) are good references for the experimental methods. Cawley et al. also describes the analytical methods.
The reproducibility of the labeling method was assessed separately. Three independent technical replicates were generated from the same RNA pool for each RNA preparation and hybridized to duplicate arrays (two technical replicates) that contain the ENCODE regions. Labeled RNA samples were then pooled and hybridized to the tiling 91-array set spanning the whole genome. Transcribed regions (transfrags; see the Raw Transfrags view) were generated from the Raw Signal by merging genomic positions to which probes are mapped. This merging was based on a 5% false positive rate cutoff in negative bacterial controls, a maximum gap (MaxGap) of 40 base-pairs and minimum run (MinRun) of 40 base-pairs.
These data were generated and analyzed by the transcriptome group at
Affymetrix
and Cold Spring Harbor Laboratories:
P. Kapranov, I. Bell, E. Dumais,
J. Drenkow, J. Dumais, N. Garg, M. Lubinsky,
Carrie A. Davis, Huaien Wang, Kimberly Bell, Jorg Drenkow, Chris Zaleski,
and Thomas R. Gingeras.
Contact: Tom Gingeras
Cawley S, Bekiranov S, Ng HH, Kapranov P, Sekinger EA, Kampa D, Piccolboni A, Sementchenko V, Cheng J, Williams AJ et al. Unbiased mapping of transcription factor binding sites along human chromosomes 21 and 22 points to widespread regulation of noncoding RNAs. Cell. 2004 Feb 20;116(4):499-509.
Cheng J, Kapranov P, Drenkow J, Dike S, Brubaker S, Patel S, Long J, Stern D, Tammana H, Helt G et al. Transcriptional maps of 10 human chromosomes at 5-nucleotide resolution. Science. 2005 May 20;308(5725):1149-54.
Kapranov P, Cawley SE, Drenkow J, Bekiranov S, Strausberg RL, Fodor SP, Gingeras TR. Large-scale transcriptional activity in chromosomes 21 and 22. Science. 2002 May 3;296(5569):916-9.
Kapranov P, Cheng J, Dike S, Nix DA, Duttagupta R, Willingham AT, Stadler PF, Hertel J, Hackermüller J, Hofacker IL et al. RNA maps reveal new RNA classes and a possible function for pervasive transcription. Science. 2007 Jun 8;316(5830):1484-8.
Djebali S, Lagarde J, Kapranov P, Lacroix V, Borel C, Mudge JM, Howald C, Foissac S, Ucla C, Chrast J et al. Evidence for transcript networks composed of chimeric RNAs in human cells. PLoS One. 2012;7(1):e28213.
Data users may freely use ENCODE data, but may not, without prior consent, submit publications that use an unpublished ENCODE dataset until nine months following the release of the dataset. This date is listed in the Restricted Until column, above. The full data release policy for ENCODE is available here.


And to one he gave five talents, to another two, and to another one, to each according to his ability
Having then gifts differing according to the grace that is given to us, let us use them:
if prophecy, let us prophecy in proportion to our faith;
or ministry, let us use it in our ministering;
he who teaches, in teaching; he who exhorts, in exhortation;
he who gives, with liberality; he who leads, with diligence;
he who shows mercy, with cheerfulness.


IoT - State of the art
Popular IoT applications
- Home automation, Smart cities.
- Wearables, Healthcare, Automotive...
Popular IoT protocols and standards
- Application level: MQTT, XMPP, AMQP. CoAP.
- Networking level: 6LoWPAN, RPL. DTLS.
Focus of this talk
Home automation using MQTT
Home automation using MQTT
A quick MQTT overview
- MQTT is based on a publisher/subscriber model.
- MQTT clients use TCP/IP to connect to a Broker.
- Brokers perform message-passing between clients and can usually be chained in a hierarchical way.
- There is a MQTT-SN specification for low-end devices.
Home automation using MQTT
Architecture basics
- Sensors:
room/temperature
, outside/humidity
.
- Commands:
room/radiator
, garage/door
.
- All devices are using a MQTT broker connected to Internet.
Privacy requirements
- Some data may be shared publicly:
outside/humidity
.
- Some data may be shared to a trusted set of people or systems:
garage/door
, room/temperature
.
- Some commands need to be protected:
room/radiator
.
- Some commands need to be secure:
garage/door
.
A 2FA would be a good thing.
Home automation using MQTT
Connecting our home to the IoT
- Naming:
my_home.domain.name/<location>/<device>
.
- Security: SSL/TLS required for MQTT requests from Internet.
Well, it was easy, wasn't it?
End of the story?
.NOPE.
DNS and SSL/TLS concerns
Both share the same usage flaw.
Enter the Blockchain
The Blockchain
- Made famous by cryptocurrencies, especially Bitcoin.
- In cryptocurrencies, acts as a ledger for transactions.
- Integrity is ensured by the network. No SPOF.
Why does it work?
- The mining process rewards people for maintaining the ledger's integrity. Mining is computational power-hungry.
- In cryptocurrencies, everyone in the network is motivated by the same incentive, i.e. getting money.
- It works because everyone is a bit greedy and that the "silent majority" outperforms the "few villains".
It looks like a very negative view of human nature, but...
TRUST < GREED
History has proven that relying on the "good will" of a few ones, just doesn't work.
Decentralization matters
Yes, all that stuff looks interesting, in theory at least...
But who cares ?
January 2015 - IBM and Samsung unveil ADEPT
Autonomous Decentralized Peer-to-Peer Telemetry
Using a
Blockchain with
Ethereum,
Telehash for communication, and
BitTorrent.
How does it work?
Twister is a fully decentralized Twitter clone.
- A Blockchain stores the full list of User Handles.
- User profiles are stored in a DHT (Kademlia).
- Posts are stored within BitTorrent swarms.
- DMs are encrypted, other messages are not.
Mapping into MQTT concepts
...and addressing security and privacy as well, while we're at it...
- A Handle is used instead of a Domain Name.
- MQTT's pub/sub model fits nicely with Twi[st]ter's one.
Now, what?
Here is some food for thought (and the Q & A session):
- Secret sharing.
Secret keys are hard to protect. Storing a key into a device makes it a SPOF, so let's split the key into parts and store those parts across multiple devices... Hint: ssss.
- Adaptive security.
NFC payments are prone to errors, but limited to a maximum amount. It's a matter of risk versus consequences.
Let's extend this principle to give a proper response to a given situation, using a Quorum.
Now, what?
- Cryptography and low-end devices.
Cryptography is costly. Do we need strong cryptography, when EFT standards still use DES (2-TDES, 112-bit key length) ? Hint: DUKPT.
- Blockchain and incentive issues.
Blockchains quickly become huge. Would a distributed Blockchain storage be possible or relevant? What about integrity? Use another Blockchain for this purpose ?
Generally speaking, what would be good incentives for non-cryptocurrencies-related Blockchains ? Example: DNSChain.


Your review will help us to improve our services.
Your personal info
Rate our overall services.
1
2
3
4
5
Write your feedback.
Submit


Assignment is a primitive statement that can occur within an action.
It is denoted by the :=
operator.
Assignments may modify multiple state variables simultaneously, in order to capture multiple return values from a called action.
The right-hand side of an assignment may be any of:
- An expression, causing assignment of concrete values
- A nondeterministic choice (
*
) operator, causing an arbitrary assignment - A call to another action, causing assignment of the action's return value(s)
Assignments may make use of free variables to assign multiple values within a function or relation simultaneously.
Assignment may also be combined with the declaration of a local variable.
Examples:
Example: State variable assignment
var x:bool
action foo = {
x := true
}
Example: relation assignment
type t = {red, green, blue}
relation bar(X:t, Y:t)
action foo = {
bar(red,blue) := true
}
Example: call assignment
action foo returns (x:bool) = {
x := true
}
var y: bool
action bar = {
y := foo
}
Example: multi-value call assignment
action foo returns (a:bool, b:bool) = {
a := true;
b := false
}
var x: bool
var y: bool
action bar = {
(x, y) := foo
}
Example: nondeterministic choice
type t = {red, green, blue}
relation bar(X:t, Y:t)
action foo = {
bar(red,blue) := *
}
Example: free variable assignment
type t = {red, green, blue}
relation bar(X:t, Y:t)
action foo = {
bar(P, Q) := true
}


{{question.threadName}} / {{question.subThreadName}} / MR Level: {{question.mrLevel}}
{{question.questionText}}
Reason:
{{question.reason}}
Action:
{{question.what}}
Assumptions:
{{question.assumptionsNo}}
Risks:
{{question.risks}}
Team Members:
{{question.teamMembers}}
Attatchments:
{{question.attatchments}}
Notes:
{{question.notesNo}}


iui-reachability.js is an extension for the iUI framework. It is in the early development stages. It is intended to perform "reachability" testing for hybrid webapps that are wrapped in the UIWebView Cocoa Class. It may also be useful for webapps that are cached using the HTML5 webapp cache -- but hasn't been tested in that configuration yet.
iUI has recently been improved so that it provides better handling of network failures during Ajax operations. At this writing that work is still in-process and reachability-demo.html can be used to test that error handling as well.
If you have any questions (or valuable suggestions!) please post them to either the iphonewebdev and iui-developers Google group.
The best way to test error handling is to use the iPhone Simulator on your Mac with airport disabled -- unplug and replug your Ethernet cable to test error handling and recovery.


[gecode-users] Compiling in Mac OS X: .dmg Vs makefile
Mauricio Toro
mauriciotorob at gmail.com
Mon Oct 20 13:38:01 CEST 2008
Hello all,
I am trying to distribute some software developed for Mac OS X Leopard Intel
using Gecode. I have a problem. I compile my software using a Gecode 2.2.2
installed using make, make install, etc and it works great. When I try to
load
my software in another Mac OS X Leopard Intel computer using Gecode 2.2.2
installed using the .dmg package, Gecode cannot be loaded and therefore
my software cannot be opened.
I am compiling my software this way:
g++ -o examples/philosopherspd2.pd_darwin examples/philosopherspd2.cpp
-I/Applications/Pd-extended.app/Contents/Resources/src/
-I/usr/local/include/flext/ -DFLEXT_SYS=2 -lflext-pd_s -undefined
dynamic_lookup -bundle -I. -lgecodesearch -lgecodecpltset -lgecodeset
-lgecodeint -lgecodeminimodel -lgecodeserialization -lgecodekernel
-lgecodesupport -ffast-math -O3
How can I compile it in order to make it work with the framework
installed by the .dmg package?
Should I do it like this?
g++ -o examples/philosopherspd2.pd_darwin examples/philosopherspd2.cpp
-I/Applications/Pd-extended.app/Contents/Resources/src/
-I/usr/local/include/flext/ -DFLEXT_SYS=2 -lflext-pd_s -undefined
dynamic_lookup -bundle
-I. -L /Library/Frameworks/gecode.framework/gecode -ffast-math -O3
Thanks,
Mauricio
--
Mauricio Toro Bermudez
Estudiante de Ingeniería de Sistemas
Pontificia Universidad Javeriana, Colombia
Stagiare à l'Ircam
1, place Igor-Stravinsky 75004 Paris,
France de 2008 à 2009
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.ps.uni-sb.de/pipermail/users/attachments/20081020/64e6ab83/attachment.htm>
More information about the gecode-users
mailing list


|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object org.apache.commons.collections.comparators.BooleanComparator
public final class BooleanComparator
A Comparator
for Boolean
objects that can sort either
true or false first.
getTrueFirstComparator()
,
getFalseFirstComparator()
,
getBooleanComparator(boolean)
,
Serialized Form| Constructor Summary | |
|---|---|
BooleanComparator()
Creates a BooleanComparator that sorts
false values before true values. |
|
BooleanComparator(boolean trueFirst)
Creates a BooleanComparator that sorts
trueFirst values before
!trueFirst values. |
| Method Summary | |
|---|---|
int |
compare(java.lang.Boolean b1,
java.lang.Boolean b2)
Compares two non- null Boolean objects
according to the value of sortsTrueFirst() . |
int |
compare(java.lang.Object obj1,
java.lang.Object obj2)
Compares two arbitrary Objects. |
boolean |
equals(java.lang.Object object)
Returns true iff that Object is
is a Comparator whose ordering is known to be
equivalent to mine. |
static BooleanComparator |
getBooleanComparator(boolean trueFirst)
Returns a BooleanComparator instance that sorts trueFirst values before
!trueFirst values. |
static BooleanComparator |
getFalseFirstComparator()
Returns a BooleanComparator instance that sorts false values before true values. |
static BooleanComparator |
getTrueFirstComparator()
Returns a BooleanComparator instance that sorts true values before false values. |
int |
hashCode()
Implement a hash code for this comparator that is consistent with equals . |
boolean |
sortsTrueFirst()
Returns true iff
I sort true values before
false values. |
| Methods inherited from class java.lang.Object |
|---|
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait |
| Constructor Detail |
|---|
public BooleanComparator()
BooleanComparator
that sorts
false
values before true
values.
Equivalent to BooleanComparator(false)
.
Please use the static factory instead whenever possible.
public BooleanComparator(boolean trueFirst)
BooleanComparator
that sorts
trueFirst
values before
!trueFirst
values.
Please use the static factories instead whenever possible.
trueFirst
- when true
, sort
true
boolean values before false
| Method Detail |
|---|
public static BooleanComparator getTrueFirstComparator()
true
values before false
values.
Clients are encouraged to use the value returned from
this method instead of constructing a new instance
to reduce allocation and garbage collection overhead when
multiple BooleanComparators may be used in the same
virtual machine.
public static BooleanComparator getFalseFirstComparator()
false
values before true
values.
Clients are encouraged to use the value returned from
this method instead of constructing a new instance
to reduce allocation and garbage collection overhead when
multiple BooleanComparators may be used in the same
virtual machine.
public static BooleanComparator getBooleanComparator(boolean trueFirst)
trueFirst
values before
!trueFirst
values.
Clients are encouraged to use the value returned from
this method instead of constructing a new instance
to reduce allocation and garbage collection overhead when
multiple BooleanComparators may be used in the same
virtual machine.
trueFirst
- when true
, sort
true
Boolean
s before false
public int compare(java.lang.Object obj1, java.lang.Object obj2)
Boolean
, this method is equivalent to
compare((Boolean)obj1,(Boolean)obj2)
.
When either argument is not a Boolean
, this methods throws
a ClassCastException
.
compare
in interface java.util.Comparator
obj1
- the first object to compareobj2
- the second object to compare
java.lang.ClassCastException
- when either argument is not Boolean
public int compare(java.lang.Boolean b1, java.lang.Boolean b2)
null
Boolean
objects
according to the value of sortsTrueFirst()
.
b1
- the first boolean to compareb2
- the second boolean to compare
java.lang.NullPointerException
- when either argument null
public int hashCode()
equals
.
hashCode
in class java.lang.Object
public boolean equals(java.lang.Object object)
true
iff that Object is
is a Comparator
whose ordering is known to be
equivalent to mine.
This implementation returns true
iff that
is a BooleanComparator
whose value of sortsTrueFirst()
is equal to mine.
equals
in interface java.util.Comparator
equals
in class java.lang.Object
object
- the object to compare to
public boolean sortsTrueFirst()
true
iff
I sort true
values before
false
values. In other words,
returns true
iff
compare(Boolean.FALSE,Boolean.TRUE)
returns a positive value.
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


For links to free global weather information, forecast services and extreme weather information see the Noonsite Weather Page
Martin-de-Vives, Ile Amsterdam 37°50'S 77°35'E
Port Alfred, Ile de Possession 46°25'S 51°45'E (Iles Crozet archipelago)
Port-aux-Français, Grande Terre 48°00'S 68°45'E (Iles Kerguelen)
* indicates port of entry


The main PhotoShare window should have now appeared. If it has not, please
ensure that you have scripting enabled in your browser, and that you do not
have a popup blocker that has blocked the window from opening. You may need
to create an exception for PhotoShare, or disable any popup blocker entirely.
Please note that PhotoShare is designed for a screen resolution of 1024x768.
It will of course work at lower resolutions, but your experience will not
be optimal.


Step 2: Register Compact Types with NCache
NOTE: This feature is not available in NCache Express and Professional Edition.
Configure the Cache
Create a Local Cache named "myCSCache" as follows:
-
Run NCache Manager.
-
Create a new project.
- Create a new cluster. Select following options from the New Cluster Wizard:
-
Cache Node: It may be the current computer and may be some other if you
want.
-
Cache name: myCSCache
- Operation Timeout: 60 sec's (default)
- Statistics Replication Interval: 600 sec (default)
- Cluster Port: 8714
-
Maximum Size: 250 MB (default)
-
Eviction Policy: Priority based
- Default Priority: Normal
-
Eviction Percentage: 5 (default) (In case of session it is recommended that turn off eviction)
-
Clean interval (sec.): 15
-
Start the cluster.
-
Verify that cache is running. For this, determine cache behavior by adding and removing objects from Statistics Window.
- Clear the cluster to make it ready for your application.
Registering the Compact Serializable Types
Perform the following steps to register your types with the configured cache:
- Stop the Cache if it is running.
- Click on the 'Compact Serialization' tab which will open up the following screen.
- Click 'Add Compact Types' button. A 'Select Compact Classes' dialog will appear.
- Browse for the assembly file that contains the compact types by clicking the 'Browse' button as shown in the figure.
- Select the classes you want to register with the cache from the loaded classes list.
- Press 'Add Class' button to add the classes in the selected classes list.
- Click 'Ok'.
- Newly added types will start appearing in the list box under the 'Compact Serialization' tab having Compact Type and Platform information.
- 'Remove' button will delete the selected type from the registered types list.
- Apply the changes to the cluster.
Note:
- For using Compact Serialization, you are supposed to define a default public constructor (parameter less) in a compact serializable type.
An object registered for Data Sharing can't be registered for Compact Serialization at a same time.
Specifying InProc or OutProc Access Mode
Please note that this cache has been configured to be used as OutProc. You can
verify this by looking at the 'Isolation Level' property on the Main tab of the
Cache details window. If you want to
change Isolation Level, do the following:
-
Stop the cluster.
-
Go to Main tab.
-
Change Isolation Level to 'Low'. This sets it for InProc. 'High'
means OutProc.
- Apply the changes to the cluster. You will notice that you no longer have the 'myCSCache
node->Start' menu enabled. This is because, the cache is now supposed to
start as part of your application process.
See Also
Run your Application


Check out some of my current projects.
- Intel Report, a project for CAL FIRE San Luis Unit to display the state of the unit
- RadLib, an Apache Cordova plugin for interfacing mobile applications with RFID readers
- Smokey Bear, a project for CAL FIRE San Luis Unit to display the current adjective fire danger
- Growing Grounds Inventory, an Android application used for tracking plant inventories at Growing Grounds Farm
Let's get in touch.


:: com :: sun :: star :: util ::
|
| interface XAtomServer |
|
- Description
- an interface to map between strings and ids
a note on atoms:
Atoms are abbreviations for strings.
When a string gets registered, it is assigned a numeric id
so that said string can always be referred to by this id.
This way strings have to be transported only once over remote connections.
Valid ids are (in this implementation) non zero, signed 32 bit values.
An atom of 0 means that the string in question is not registered
Additionally there is the abstraction of atom class:
Atoms are grouped into classes, so that an id can be assigned
to multiple strings, depending on the class context. The main
advantage of this is that atoms in one class may be kept
to small numbers, so that bandwidth can be reduced by sending
the atoms only as 16 bit values. Note that it is up to the user in this
case to handle overflows.
|
| Methods' Summary |
| getClass |
returns a whole atom class
|
| getClasses |
returns mutltiple atom classes
|
| getAtomDescriptions |
returns the strings for an arbitrary amount of atoms of multiple classes
|
| getRecentAtoms |
returns the atoms that have been registered to a class after an
already known atom
|
| getAtom |
registers or searches for a string
|
| Methods' Details |
getClass
- Description
- returns a whole atom class
- Parameter atomClass
- which class to return
- Returns
- the descriptions for all atoms of class
atomClass
|
|
getClasses
| sequence< sequence< AtomDescription > > |
| getClasses( |
[in] sequence< long > |
atomClasses ); |
- Description
- returns mutltiple atom classes
- Parameter atomClasses
- which classes to return
- Returns
- the descriptions for all atoms of the requested classes
|
|
getAtomDescriptions
| sequence< string > |
| getAtomDescriptions( |
[in] sequence< AtomClassRequest > |
atoms ); |
- Description
- returns the strings for an arbitrary amount of atoms of multiple classes
- Parameter atoms
- describes which strings to return
- Returns
- the strings for the requested atoms
|
|
getRecentAtoms
| sequence< AtomDescription > |
| getRecentAtoms( |
[in] long |
atomClass, |
| [in] long |
atom ); |
- Description
- returns the atoms that have been registered to a class after an
already known atom
Hint to implementor: using ascending atoms is the easiest way
to decide, which atoms are recent.
- Parameter atomClass
- the class in question
- Parameter atom
- the last known atom
- Returns
- all atom description that have been added to class
atomClass after atom
|
|
getAtom
| long |
| getAtom( |
[in] long |
atomClass, |
| [in] string |
description, |
| [in] boolean |
create ); |
- Description
- registers or searches for a string
- Parameter atomClass
- the class of atoms in question
- Parameter description
- the string in question
- Parameter create
- if true a new atom will be created for an unknown string
else the invalid atom (0) will be returned for an unknown string
- Returns
- the atom for the string
description
|
|
Top of Page
Copyright © 2013, The Apache Software Foundation, Licensed under the Apache License, Version 2.0. Apache, the Apache feather logo, Apache OpenOffice and OpenOffice.org are trademarks of The Apache Software Foundation. Other names may be trademarks of their respective owners.


Customize Tour
Travaller Information
Full name
Please enter full name.
Email
Please enter email.
Email is invalid.
Phone number
Please enter phone number.
Nationality
Please enter the nationality.
Destinations you would like to include
Destination
Please enter the destination.
Estimated arrival date
Please select start arrival date.
Estimated travel duration
Please enter the estimate duration.
The estimate duration is invalid.
Do you have any plans or ideas yet?
SEND
The request has been sent successfully.


VITUNES-RM(1) BSD General Commands Manual VITUNES-RM(1) NAME vitunes-rm -- remove a file or a URL from the database SYNOPSIS vitunes -e rm [-f] URL | path DESCRIPTION To remove a single file or URL from the vitunes(1) database, the rm e- command may be used. Normally, a prompt is shown as a safety measure. This prompt can be avoided using the -f flag, to force the removal. Note that to remove files, the full, absolute path to the file must be provided, as obtained from realpath(3). EXAMPLES To remove a single file from the vitunes(1) database, use: $ vitunes -e rm /path/to/file.mp3 To remove a URL, such as that for an Internet radio stream, use: $ vitunes -e rm -f "http://<IP_ADDRESS>/listen.pls" SEE ALSO vitunes(1), vitunes-add(1), realpath(3) AUTHORS Ryan Flannery<EMAIL_ADDRESS>BSD January 17, 2015 BSD


“Cosmology” it is the study of evolution, origin and ultimate fate of universe. According to religious studies, cosmology is about a theistically created world which is governed by supernatural powers. But according to scientists, modern cosmology deals with creating the most complete understanding of the universe that is stable with scientific observations and elucidated with natural forces. The chronology of universe tells us about the history and future of universe in accordance with the big bang cosmology.
Our universe is estimated to be roughly 13.8 billion years old, which is approximately 130 million years whereas in comparison the solar system is only about 4.6 billion years old. Our universe evolved with the Big Bang as an unbelievable hot and dense point. When the universe was just hundredth of a billionth of a trillionth of a trillionth of a second in age, that is, 10-34 second of age it went through an immense burst of expansion which was known as inflation. During this time, universe doubled in size at least about ninety times, transforming from subatomic size to golf ball size. The Big Bang was not an explosion in the usual way because the universe did not expand into space as no space existed before the universe. The universe did not expand only from any single spot after the Big Bang rather the space itself has stretched and carried matter with it.
The first era is termed as the Planck epoch where the temperature was so high that the four fundamental forces that are electromagnetism, weak nuclear interaction, gravitation and strong nuclear interaction were only one fundamental force. As the expansion of the universe continued it cooled down and crossed transition temperatures where forces separated from each other. This was the time of phase transition much similar to freezing and condensation. After this the grand unification epoch began when gravitation was separated from the other forces of nature, which are known as gauge forces. The grand unification epoch came to an end when the grand unified theory forces which described the non- gravitational physics in this epoch further separated into the strong and electroweak forces. After this came the electroweak epoch which was 10-36 seconds after the Big Bang, where the temperature was low enough to separate the strong forces from electroweak forces. After this the inflation came to an end when the inflation field decayed into ordinary particles and the process was called “reheating”. This is usually quoted as the time “after the Big Bang “. This occurred roughly 10-32 seconds after the Big Bang.
After inflation the growth has continued but is at a slower rate and the universe was filled with quark- gluon plasma. Then came the era of quark epoch where the fundamental forces took their present forms and the fundamental particles had mass , but the temperature of the universe was still high to form hadrons . With the expansion of space the universe cooled down and matter was formed. Just a second after the Big Bang universe was filled with protons, neutrons, electrons, photons, neutrinos. This era was termed as the hadron epoch. These hadrons and anti – hadrons then left leptons and anti- leptons which dominated the mass of universe. After 10 seconds of Big Bang, most of the leptons and anti- leptons were wiped out and photons dominated, hence the photon epoch. After the first three minutes lighter elements evolved during the process of Big Bang nucleosysnthesis. Temperature cooled down further from 1032 Kelvin to 109 Kelvin. During this period the protons and neutrons collided to make isotope of hydrogen that is deuterium. Most of the deuterium then combined to form helium and trace amounts of lithium were also produced. Hydrogen and helium atoms were then formed when the density of the universe began to fall. This happened roughly 377,000 years after the Big Bang .This was the period of recombination where free electrons got captured by the ions and formed electrically neutral ions. This was followed by decoupling where the photons travelled freely and the universe became transparent.
About 400 million years after the Big Bang, universe began to move out from the cosmic dark ages, this was during the epoch of reionization. This lasted for more than half- billion years. During this time clumps of gases collapsed to form the first stars and galaxies, whose very energetic ultraviolet light ionised and destroyed most of the neutral hydrogen. The first form of stars was the population III stars. This was then followed by collapsing of large volume of matter which formed a galaxy. This led to formation of population II and then population I star. Our solar system was born about 9 billion years after the Big Bang. A fragment of a molecular cloud comprising of hydrogen and traces of other elements collapsed to form a large sphere in the centre which became the sun. The surrounding accretion disk then came together to form the planets, comets, asteroids.
The ultimate fate of universe depends upon the physical constants: cosmological constant, proton decay and the natural laws. It can happen due to ‘Heat death’ where energy density of universe decreases and reaches thermodynamic equilibrium where no structures are possible, ‘Big rip’ where clusters of galaxies and finally solar system will torn apart, ‘Big crunch’ where the universe would contract to a hot dense state or ‘Vacuum instability’ where the space-time might collapse into a lower energy state leading to a true vacuum which could then expand outward from that point with the speed of light.


Emotional Feedback
Pairing
Pairing with others to solve challenges is nerve racking to me. It amplifies my insecurities about being slow
or not understanding. When I am alone I can pace myself or come back to a challenge after reflecting. It is enjoyable
to share ideas with another student. This was a reason I decided to apply to DBC. Doing challenges over google hangouts
can become frustrating. You cant read the social cues that are present when in person. It is easy to start talking over
your pair since you cant always see if they are about to speak.
Feedback
Getting feedback has been enlightening. I have learned the importance of getting to know my partner before jumping
into a challenge. It has been something mentioned in my feedback that would have been better for me to do. I thought
I was doing this but from reading my feedback I do not understand their learning style. For my next pairing I need to
ask that specific question so I can be aware while coding.
I enjoy writing the feedback. Having to be specific has helped me narrow down what I enjoyed most from the sessions and learned.
When offering actionable feedback it can be tricky. Sometimes the first thing that comes to mind is a preference of mine that they are unaware of. Offering feedback on that isnt helpful since it can only apply to me and how I felt. I usually give actionable feedback on coding issues that they became stuck on and could benefit from practicing more.


{% extends "master.html" %} {% block navigation %} {% if user %}
Pen down your thoughts...
There are no posts in the website! :( Please click here to start writing one! Make sure you're Logged In first!


Test queries against Solr backend
Handler URL:
Queries
{{query.name}}
{{query.definition}}
Running
{{activeQuery}}
{{status}}
{{docsStr}}