After a lot of plotting a scheming, I managed to get an invite to tag along with the Old Colony Four Wheel Drive Club out of Massachusetts. Diane and I didn't make it to the campground until late Friday night, so Saturday morning arrived in a hurry. After a quick breakfast, I met Rick Boiros in person for the first time and soon everyone was lining up.  Most of them were equipped with a winch, running 33s or larger, and locked f&r. After the normal socializing and Jeep talk, we moved out for Vermont.
Rick and his '77 CJ-7
Well, I'm not sure if we were on state or national land, but the sign indicated it was legal for wheeling. We turned of the road onto a freshly graded trail to a cabin. After the cabin the road was ungraded and the fun began. I was the third or fourth Jeep from the front out of about 20 Jeeps or so and one Sammy. The first difficult obstacle and they had to get the strap out for me. I wasn't the only one to have problems with this obstacle plus there were a few mechanical problems, so it took a while for the pack to get moving again.
Eventually, everyone made it through and we headed up this trail the was rocky and muddy. This trail dead ended in a fairly recent area that had been logged. We paused here for lunch while the half the group continued down another more difficult trail. Finally, we all turned around and started after the rest of the group. I was now tail gunning so everything was real chewed up by the time I hit it.
This trail got tough fast, we were climbing up a slippery, rocky, tight trail. There is no way a full sized vehicle would have fit. Chris Komar, in his Land Rover with narrow 33s was the first to need to winch himself. Even with ARBs f&r he got jammed in a bad spot. He wasn't moving much further when he realized he had broken his front axle.
After a little discussion we decided to hang out and fix it. Chris was carrying, among other spare parts, the four different axle shafts for his Rover. The rest of the group kept moving and we could still hear them moving slowly over the difficult trail for the most of the hour and fifteen it took to repair Chris's axle.
| Chris pulling the axle from his Land Rover |
By the time we were moving again, there were only four in our group. Rick Boiros was leading in his '77 CJ-7, Chris and Barbara in his Land Rover, Rich Banfield, president of New England Four Wheelers, in his '86 CJ-7, and me trying to keep up in my '81 CJ-7. The trail only got tougher from here. Rick didn't have any problem in his CJ-7 with 35s locked f&r, but Chris and Rich had to winch a few times and I had to winch 3 or 4 times. By the time we made it out of the woods, it was dark.
Rich and his '86 CJ-7
All in all the day was a blast. Very challenging wheeling with plenty of opportunity to try out my new winch (only two pulls before this weekend.) I was wheeling most of the day with 3 very experienced people and learned a lot about winching technique. I found it very difficult to winch with manual steering unless you have three arms. After the day was over I decided that Diane is doing all my winching if she is available.


My name is Edin Filipovic and I come from Bosnia and Herzegovina. Graduated at Faculty of Philosophy in Zenica and during that time I have learnd English language. More details about me are in the rest of this paragraph
On my first day at Epicodus here is the list of things i have learned:
I have heard first time about GitHub in the class and use of GitHub. Here is a list of things I've learned about GitHub:
Learned how to:
One of the coolest things I have learned during first week at Epicdous was CSS and how to manipulate it in order to edit a webpage. I have learned how to:
Branching is the act of creating multiple copies of similar code in the same repository. When code is fine-tuned and tested in the branch, and we know it works, we can add it into master. This process is called merging. I have learned how to:
In further lessons I have learned about:
What is Bootstrap and how does it helps us?


Fill in this form to find out your Akan name. Akan names are derived from Ghanian culture whereby people are given their first name based on their gender and the day of the week during which they were born on. The system will use your birthday details to calculate the day of the week you were born on and generate your male/female Akan(week) name.


stephentu's blog
2020-08-13
Volume of Symmetric Operator Norm Bounded Matrices
2019-03-14
Yet Another Kalman Filter Writeup
2018-09-05
The Top Singular Value of Identity Plus a Rank One Perturbation
2018-09-01
A Simple Proof for Lower Bounding the Expected Norm of a Gaussian
2018-07-01
H-infinity Optimal Control via Dynamic Games
2018-06-18
An Upper Bound on the L2 Operator Gain for Discrete-time Volterra Series
2018-02-03
Path Integral Optimal Control in Continuous Time
2018-01-21
The Gradient of Optimal Control Problem
2018-01-12
Path Integral Stochastic Optimal Control
2018-01-08
Maximum Entropy Linear Quadratic Regulator
2017-12-10
Bennett's Inequality for Martingales
2017-12-09
The Discounted Infinite-Horizon LQR Problem
2017-11-12
A Special Case of Boolean Hypercontractivity
2017-11-04
Markov's Inequality for Matrices
2017-10-30
Fibonacci Numbers via Generating Functions
2017-10-23
Packing Hypercubes via the Probabilistic Method
2017-10-16
Upper and Lower Tails of Gaussian Maxima
2017-10-09
Relating the Total Variation Distance to the $L_1$-norm
2017-09-16
Cauchy's Estimate for Derivatives
2017-09-02
RKHS Defined on Subspaces
2017-04-01
No Gain Margins for LQG
2017-03-31
Gain Margins for LQR
2017-03-26
A Frequency Norm Bound Constraint to Hard Time-Domain IQC
2017-03-26
Reachability and Controllability
2017-01-24
The real and complex operator norms coincide for a real-valued matrix
2017-01-22
Hankel versus H-infinity norm
2016-12-29
H-infinity state feedback synthesis
2016-12-26
Dissipative systems and gradient flow
2016-11-14
Computing the H-infinity norm of a linear system
2016-11-13
Optimal control via the linear quadratic regulator (LQR)
2016-09-03
Dual certificates for nuclear norm minimization
2016-08-20
Deriving the dual of the LASSO program
2016-08-17
An operator norm inequality for block partitioned positive semi-definite matrices
2016-08-16
A proximal view of projected gradient descent
2016-08-08
A useful expectation identity for non-negative random variables
2016-07-25
Two quick convergence proofs for gradient descent
2016-06-12
Approximating the unit ball of finite dimensional spaces
2016-06-03
Deriving the dual program in SDCA
2016-06-03
A useful matrix inverse equality
2016-05-26
Best diagonal approximation to a PSD matrix
2016-05-09
Key ideas in basic functional analysis
2016-04-29
Basel problem via Fourier analysis
2016-04-14
Complex differentiation is quite complex
2016-02-28
List of PhD reflections
2016-01-02
Random features as an approximate kernel expansion
2015-12-17
Robust regression
2015-12-11
Inequality regarding limit superior and limit inferior for sequences of sets, take two
2015-12-03
An approximation result for continuous functions by polynomials using probability
2015-09-06
The expectation of random Fourier features via trigonometric identities
2015-07-25
Motivating Newton's method via gradient descent in a particular Hilbert space
2014-11-23
Sampling from convex bodies: analyzing ball walk
2014-11-01
Elementary facts regarding bounded linear operators
2014-10-07
Eigenvalues and singular values as optimization
2014-10-01
Subdifferential of a norm
2014-09-26
Elementary properties of orthogonal projections
2014-09-22
Limit superior and limit inferior for sequences of sets
2014-09-06
Using linear matrix inequalities to certify convergence of gradient descent
2014-08-05
The Dirichlet distribution as a conjugate prior for multinomial/categorical likelihood models
2014-05-12
A quick analysis of the expectation maximization algorithm
2014-02-20
Binary minimax hypothesis testing
2014-01-12
Thoughts on dating and the geometric distribution


If you write useless texts in Vim which no one wants to read the lines are going longer and longer until they aren’t fit at the display again and the vim editor needs to scroll this long long lines in order to display it completely.
set textwidth=80
- breaks automatically long lines after 80 chars
BUT: do you really want to break long lines only for your tool chain?
set wrap
- Wraps long lines at the end of the “window”
BUT: makes navigation in the long line difficult
Use gj
, gk
, g0
, `g^``, …
let g:remappings = ["$", "j", "k", "0", "^", "<end>", "<home>", "<up>", "<down>"]
function ToggleLineHandling()
if !exists("b:LineHandling") | let b:LineHandling = "normal" | endif
if b:LineHandling == "normal"
let b:LineHandling = "continuous"
setlocal wrap
setlocal nolist
for i in g:remappings | exe "noremap <buffer> " . i . " g" . i | endfor
else
let b:LineHandling = "normal"
setlocal nowrap
setlocal list
for i in g:remappings | exe "unmap <buffer> " . i | endfor
endif
endfunction
-> nolist
disables linebreak in a word
let g:myLangList = [ "de_20", "en_us" ]
let g:myThesaurusList = [ "thesaurus-de.txt", "" ]
let g:startLang = 0
function! ChangeSpellLang()
if exists("b:myLang")
let b:myLang = b:myLang + 1
else
let b:myLang = g:startLang
endif
if b:myLang >= len(g:myLangList)
let b:myLang = -1
setlocal nospell
else
exe "setlocal spell"
exe "setlocal spelllang=" . g:myLangList[b:myLang]
exe "setlocal thesaurus=$HOME/.vim/" . g:myThesaurusList[b:myLang]
endif
endfunction
map <F7> :call ChangeSpellLang()<CR>
use both: :set spelllang=de_20,en_us
Complete using thesaurus i_CTRL-X_CTRL-T
Complete using spell i_CTRL-X_CTRL-S
Vim-online-thesaurus: http://www.vim.org/scripts/script.php?script_id=4588
g CTRL-g
// w !wc -w


--- layout: post title: 'Inspecting a live Ruby process: Day 2' post_id: 150 categories: - tips & tricks date: 2006-09-23 08:42:00.000000000 -06:00 author: Jamis permalink: 2006/9/23/inspecting-a-live-ruby-process-day-2.html ---
I knew when I posted yesterday’s article on inspecting a live Ruby process that I wasn’t the first to have done that with GDB—I just didn’t know of anyone else who had. But given that I’m not a GDB guru, and there are much brighter people than me playing with Ruby’s internals, I was sure it had been done before.
I was not wrong, apparently. And not only had it been done before, it had been done better. I was delighted to see that Mauricio Fernandez has shared a collection of GDB helpers that make it easy to cheat.  Really, really cool. Definitely give it a look.


Conditional Command
What is it?
A conditional command runs one of two commands. The command to
run is chosen during initialization of the conditional command
based on the condition parameter.
Properties
- Requires
- The subsystem that this command requires.
- OnTrue Command
- Command to run when condition is true
- OnFalse Command
- Command to run when condition is false
- Parameters
- Variables to be passed into the command. Data can be of
types boolean, byte, int, long, double, or string.
- Parameter presets
- Preset values for command parameters that can be used when
a command is invoked
- Button on SmartDashboard
- Whether or not to automatically place a button on the
SmartDashboard.
- Run When Disabled
- Sets whether or not this Command should run when the robot
is disabled.
- Sets whether or not this Command should be added to
Autonomous Chooser.


Instructions The objective is to use the "crystals" below to try and match the target value.
Target Value:
Your Number:
Wins:
Losses:


--- layout: full ---
In response to the decline in religious discourse in our culture, our purpose is to provide a forum for open, respectful, sincere, and intellectually honest dialogue about religion that informs and fosters community.
In 2009, a group of friends were talking about their disappointment in the current climate of theological discourse in America. Not only did there seem to be a lack of serious public discussion about important theological topics, but much of the discussion that did take place seemed to be unfair, unbalanced, and dishonest. Together, these friends desired to engage with their culture and their local communities in sincere, open, honest, and intellectually honest theological dialogue. Thus, the Fox Valley Theological Society was formed.
It is our desire, that the Fox Valley Theological Society would serve as a community forum, where all participants have a voice in the conversation, and challenged to think deeply about ultimate and eternal issues. As a society, we are committed to a discussion that is marked by four main characteristics:
To that end, the Fox Valley Theological Society is hosting discussion forums on a variety of topics in public settings. Each forum consists of a 40 minute lecture followed by 45 minutes of open discussion and Q&A. All of our speakers are members of local communities and eager to continue in the conversation with anyone interested.


class: center, middle # BitWatt: Power and the Blockchain --- # Agenda 1. BitCoin and Blockchains 2. Ethereum 3. BitWatt 4. Ethereum as Development Platform 5. Liam's Critical Path to an Ethereum web app... 6. Solidity 7. Programmable Power 8. References --- # BitCoin and Blockchains - Data container: Similar to a log file or transactional database - Democratic: anyone can add transactions, but must register an _Account_ - Transactional: Each addition of data is a _Transaction_ - Cryptographic: _Transactions_ is encrypted and signed - Uneditable: Transaction history is inviolable (hence General Ledger) - Distributed: Every _Account_ holder has a copy of the ledger - Decentralised: Party A transfers X amount to Party B; Parties C, D, E etc 'witness' the transaction by mining --- # Ethereum - BitCoin 2.0: Part of new generation of blockchains - BitCoin's Limits: _Accounts_ transfer single quantities (of BitCoin) - Ethereum is agnostic of 'payload' of transactions: - Could be _multiple_ quantities - Could be other data: text, images, 'Happy Birthday' greeting cards - These generalised transactions need a specification of their meaning - Hence, the idea of 'Contracts': specifications of the semantics of arbitrary transactions - Still needs witnessing, mining etc - 'Ether' is the (default) currency (converible to BitCoin, AUD etc) > _Ethereum is a public blockchain platform with programmable transaction functionality. It provides a decentralized virtual machine that can execute peer-to-peer contracts using a cryptocurrency called Ether (unofficial code ETH)._ ( [Ethereum - Wikipedia, the free encyclopedia](https://en.wikipedia.org/wiki/Ethereum) ) --- # BitWatt - Could we have a decentralised, secure, low-cost, automated and inviolable register of power transfers between generators and consumers? - Combine Ethereum with renewable energy - Multiple scenarios: - Community Power - Replace current grid - Multi-tenant buildings - Integrated with power grid vs parallel and self-contained power economy - Closed loop: 'private' block chains vs. 'public' - deployed to the Ethereum main block chain - 'Private' is useful for testing, proof-of-concept, costless (no 'real' ether required) --- # Ethereum as Development Platform NB: Ethereum is 'early adopter' technology. Tools in state of flux! ![Ethereum Components](https://camo.githubusercontent.com/90baf3a08e818cf71d30eb8be508e82a3b7342cf/687474703a2f2f646f75626c657468696e6b636f2e6769746875622e696f2f6370702d657468657265756d2d63726f73732f696d616765732f7461726765745f646570656e64656e63795f67726170682e737667) --- # Ethereum as Development Platform - Implementation of Ethereum protocol - [go-ethereum](https://github.com/ethereum/go-ethereum) - [cpp-ethereum](https://github.com/ethereum/cpp-ethereum) - Ways of developing contracts - [Ethereum Mix](https://github.com/ethereum/wiki/wiki/Mix:-The-DApp-IDE) - [Truffle](http://truffle.readthedocs.io/en/latest/) - Many, many other tools! - Beware of outdated tools, docs - only use 2016 releases, preferably very recent... **Strongly recommend _go-ethereum/geth_ AND _truffle_!** --- # Liam's Critical Path to an Ethereum web app... - Install go-ethereum ( [Building Ethereum · ethereum/go-ethereum Wiki](https://github.com/ethereum/go-ethereum/wiki/Building-Ethereum) ). - Setup account ( See [Managing your accounts](https://github.com/ethereum/go-ethereum/wiki/Managing-your-accounts) ): ``` geth account new ``` - **Take note of your password and address!** - Create an initial file called _genesis.json_ with the following contents ( [what this means](http://ethereum.stackexchange.com/questions/743/getting-more-ether-on-a-private-test-net) ): ``` { "nonce": "0x000000000000002a", "timestamp": "0x0", "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000", "extraData": "0x0", "gasLimit": "0x8000000", "difficulty": "0x100", "mixhash": "0x0000000000000000000000000000000000000000000000000000000000000000", "coinbase": "0x0000000000000000000000000000000000000000", "alloc": { "0x777494636dbffd8da89e3b26bacdfb1a191ea127": { "balance": "20000000000000000000" } } } ``` --- # Liam's Critical Path #2 - Run: ``` mkdir blockchain geth --nodiscover --unlock
--genesis=genesis.json --datadir="blockchain" -verbosity 4 --port 30301 --rpc --rpcport 8545 --rpccorsdomain "*" --mine console 2>> ethereum.log ``` or follow these instructions: [Creating a Private Chain/Testnet | Ethereum Tutorials and Tips by Hudson](https://souptacular.gitbooks.io/ethereum-tutorials-and-tips-by-hudson/content/private-chain.html) --- # Liam's Critical Path #3 - Install truffle (requires Node.js and npm) ``` npm i -g truffle ``` - Create a new truffle app ``` mkdir myapp cd myapp truffle init ``` - Compile and build the default app ``` truffle compile truffle build ``` - Deploy the app: ``` truffle deploy ``` --- # Liam's Critical Path #4 - Run the truffle server ``` truffle serve ``` - Open http://localhost:8080 in your browser - To test a transction, first create a second account in _geth_, then try transferring an amount to the 2nd account address - For quick testing, run the testrpc server instead of geth npm i -g ethereumjs-testrpc testrpc - Then learn Solidity to write contracts! --- # Solidity - Learn a new (contract) programming language! - [Solidity — Solidity 0.2.0 documentation](http://solidity.readthedocs.io/en/latest/) - Implement contractual variations: - Fixed price watts (pegged to ether currency) - Varying prices - Negotiated prices - Auction? - Time-sensitive? - Supply-sensitive? - Loans & interest accrual? - Good examples from BitTradeLabs: - [Programmable Money](http://bittradelabs.com/blog/the-power-of-programmable-money) --- # Mix - IDE (Integrated Development Environment) - Tutorial: [Mix: The DApp IDE · ethereum/wiki Wiki](https://github.com/ethereum/wiki/wiki/Mix:-The-DApp-IDE) - Very powerful, hard to get working web application... --- # Programmable Power - That's great, but where's the power? - 2 x lamps, 2 x Efergy monitors - These **should** log consumption that can be downloaded as a spreadsheet - Can be fed in to Ethereum app as _BitWatt_ debits, e.g. 2 "net consumer" accounts. Need also 2 x "net generator" accounts. - (Exercise best left for the reader) --- # References ## Docs - [Ethereum Homestead Documentation — Ethereum Homestead 0.1 documentation](http://www.ethdocs.org/en/latest/) - [orgs/ethereum/rooms - Gitter](https://gitter.im/orgs/ethereum/rooms) - [Ethereum Community Forum](https://forum.ethereum.org/) - [Introduction | Ethereum Guide](https://gavofyork.gitbooks.io/turboethereum/content/) ## Core Tools - [Install the Command Line Tools](https://www.ethereum.org/cli) - [Mix: The DApp IDE · ethereum/wiki Wiki](https://github.com/ethereum/wiki/wiki/Mix:-The-DApp-IDE) - [ethereum/mist: Mist browser](https://github.com/ethereum/mist) - [Releases · ethereum/mix](https://github.com/ethereum/mix/releases) - [Releases · ethereum/webthree-umbrella](https://github.com/ethereum/webthree-umbrella/releases) --- # References #2 ## Private Chains - [Setting up private network or local cluster · ethereum/go-ethereum Wiki](https://github.com/ethereum/go-ethereum/wiki/Setting-up-private-network-or-local-cluster) - [Creating a Private Chain/Testnet | Ethereum Tutorials and Tips by Hudson](https://souptacular.gitbooks.io/ethereum-tutorials-and-tips-by-hudson/content/private-chain.html) ## Truffle - [A 101 Noob Intro to Programming Smart Contracts on Ethereum —<EMAIL_ADDRESS>- [Truffle](http://truffle.readthedocs.io/en/latest/) - [ConsenSys/truffle: A development framework for Ethereum](https://github.com/ConsenSys/truffle) - [ethereumjs/testrpc: Fast Ethereum RPC client for testing and development](https://github.com/ethereumjs/testrpc) - [ethereumjs-testrpc](https://www.npmjs.com/package/ethereumjs-testrpc) - [iurimatias/EtherSim: EtherSim is an Ethereum RPC simulator for testing and development purposes](https://github.com/iurimatias/EtherSim) --- # References #3 ## Metamask - [MetaMask](https://metamask.io/) (untested but promising) ## Other - [PowerAPI](http://powerapi.org/) - [Spirals-Team/powerapi: PowerAPI is a middleware toolkit for building software-defined power meters](https://github.com/Spirals-Team/powerapi) - [BitWatts](http://bitwatts.powerapi.org/)


Scrawl-canvas v8
- Canvas test 006
Canvas tween stress test
Click on porthole to increase number of star tweens
Test purpose
Create and run many tweens/tickers, each associated with its own entity
Test to see how many tweens a browser can run at a reasonable speed
Touch test:
should work as expected
Annotated code


NCP Informs Maharashtra Governor Of Ajit Pawar’s Replacement As Legislature Wing Leader
by PTIBookmark
Nationalist Congress Party Leader Jayant Patil went to the Raj Bhawan today with a letter to Governor Bhagat Singh Koshyari to inform him about replacement of Ajit Pawar as the legislature party leader.
The governor is not in Mumbai, a Raj Bhawan official told PTI.
Pawar was removed as the NCP's legislature unit leader on Saturday, hours after he joined hands with the Bharatiya Janata Party in a coup and took oath as the deputy of Maharashtra Chief Minister Devendra Fadnavis.
Fadnavis on Saturday returned as chief minister propped up by Ajit Pawar, who was made his deputy, just hours after the new alliance of Shiv Sena, the NCP and the Congress reached a consensus that Sena chief Uddhav Thackeray will be their chief ministerial candidate.
Fadnavis and Ajit Pawar were sworn in by Koshyari at a hastened ceremony, leading to lifting of the President's rule in the state.
On Saturday evening, the NCP removed Ajit Pawar as the party's legislature unit head, saying his move was not in line with the party's policies.
State NCP chief Jayant Patil will have all the constitutional rights till the next legislature party leader is elected, the party said.
The resolution passed at the NCP meeting also said that Ajit Pawar's right to issue a whip was also revoked.
Ajit Pawar, the NCP chief's nephew, was elected as the legislature party leader on Oct. 30 following the results of the Maharashtra Assembly elections.


Using the systemp_w_calibration.grc Program
The video shown here explains the features in this program.
1. Before Starting The Program
The video here explains how set up the horn and make adjustments to the user-defined settings referred to below.
-
Check the user-defined settings illustrated below. These are the
Variable
blocks in the upper right corner of the Gnuradio canvas.-
To change a value, double click on the box and then type the value in the Value box and hit OK.
-
integration_time1
is the short integration time, andintegration_time2
is the long integration time. These can be changed to any value at 0.4 s or above. -
Be sure that the file path in the
prefix
box is correct. This is the folder where the data files will be saved.Hints on setting the file path correctly: (These steps are explained in the setting up the horn video.)
- Open the File Navigation window (folder icon).
- Navigate to the folder to which you want to save the spectrum files.
- Right click on the folder.
- Select
Properties
. - Double click the
Parent folder:
path and copy it to the clipboard. - In the
prefix
variable box paste the path name inside quotes in theValue
box. (Delete any existing path name.) -
Then append the actual folder name to the end of the parent path. Be sure to separate folder names with / and end with /.
EXAMPLE:
Parent folder:
home/Jansky/radio_astronomy
data folder name:
horn_data_2020
Value to put into the
prefix
variable box:
“home/Jansky/radio_astronomy/horn_data_2020/” (Include the quotes)
-
-
CAUTION: If you run the program on a laptop without the power cord plugged in, the computer may go into a sleep mode and stop running the program, depending on the length of the run. Change the power settings on your computer so that it never suspends or goes to sleep.
2. After Starting The Program
- The first screen that appears looks like the following:
-
This display is used for most observations that are uncalibrated.
-
Adjust the
ymin
andymax
values to scale the graph as desired. -
Fill in the
azimuth
,elevation
, andlocation
, if desired. NOTE: When entering these values, you must hit ENTER after each entry in order for it to get recorded by the program.
These parameters are included in the title, as described in the Saving a Spectrum to a Data File section below. This is also demonstrated in the video on how to save data.
-
The
Short Integration
option is good for quick observations and demonstrations. Switch toLong Integration
for smoother data when a pointing is settled on and you are ready for a longer run. -
The
Clipped Spectrum
is the better selection for most viewings. TheFull Spectrum
is good for demonstrating how the signal processing affects the spectrum. It also might be useful for the expert user who wants the full spectrum for some reason.
3. Saving a Spectrum to a Data File See the video on how to save data
-
The spectrum that is currently being displayed on the screen can be written to a .csv data file by clicking the
Capture Current Spectrum
button. The data file is written to the folder under the path in theprefix
Variable box. -
When
Writing to file
is selected under theWrite to csv File
window, a data file will be written to a new file in the data folder each time an integration time elapses. For instance, if Long Integration is selected and is 10 s, then every 10 s a new file is written. So for a 20 minute run, a total of 120 files will be written to the data folder.
This option is useful when running a drift scan or for when the user sets the telescope to collect data at a later time when the user is not able to be present.
- Data File Format:
-
The .csv format is a .txt data file that can be opened in any spreadsheet.
-
When opened in a spreadsheet, the data will appear in 2 columns. The first columns contains the frequency, in MHz, from 1414 MHz to 1424 MHz. The second column is the signal.
-
A graph of Signal vs. Frequency can easily be created after opening a file in a spreadsheet.
-
The file name has a format that contains the date, time, location, azimuth, and elevation, with “_spectrum” at the end. The location, azimuth, and elevation are recorded with the values in the corresponding fields on the spectrometer inferface screen.
-
As an example, the filename “2020-07-15_Morgantown_200_30_spectrum” contains data that was collected on July 15, 2020 in Morgantown with the telescope pointed at an azimuth of 200 degrees and an elevation of 30 degrees.
-


“To live is to fight and to fight is to live.”
Ryu Hoshi
I was born on the 21 of July In 1964. As a child, I was orphaned and left with no memory of my parents or if they were alive. I was accepted by a man named Goken, who raised me and took on my training as a martial artist.
I grew up to be a quiet and serious man, yes. My main goal is to master my fighting style perfectly. I love to travel and I take my travel and training very seriously.
I would like to teach people the skills I have achieved, but it requires special things, so if you want to be like me you need to acquire one of these things and then you can become like me.
I started learning fighting at my master Gouken's castle, I was beaten at head way too often to remember when exactly.
I fought a lot with my brother Kena, he taught me how to tolerate pain and many tricks. Subsequent experience I gained in street fights.
It was my first tournament. When I beat everyone, I was able to fight with the tournament host, Sagat. In that battle, I hit him hard.
I gained valuable experience fighting with my father's killer Akuma, he let me reveal the secret power of Satsui-no-hado.
After being brainwashed by Bayson, I became more vigilant and stronger.
It was my second tournament, and here I gave the heat to everyone. And I beat the evil Bayson.
Some time after the second tournament, and entered a new tournament to further improve his skills, as well as to meet his old friend Ken in a rematch.
I ran into Bayson again, after a long epic battle, I finally defeated him forever.
I took part in the Third World Warriors Tournament to further advance my abilities. My most memorable battle was with Hugo, who was able to withstand the Shin Shoruken technique and stand up for himself.
Martial arts in general, mizuyokan (Japanese sweet bean jelly), warrior's way, grapes, meat loaf, help people when they have problems, travel, nature.
Spiders (once woke up with one in his mouth), materialism, wearing shoes, Satsui no Hado, Akuma for "killing" my teacher, Bison, murder.


The goal of jamba is to provide useful custom functions for R data analysis and visualization.
A full online function reference is available via the pkgdown documentation:
Functions are categorized, some examples are listed below:
The R functions in jamba
have been built up over several years, often based upon and citing the relevant discussion from Stackoverflow, R-help, or Bioconductor, along with the principal author(s). Almost every function is some sort of wrapper around existing R functions – designed for specific cases where I can make it faster, more flexible, or customized to make my analysis life easier. Kudos and thanks to the original authors! The R community is built upon the collective greatness of its contributors!
Most of the functions are designed around workflows for Bioinformatics analyses, where functions need to be efficient when operating over 10,000 to 100,000 elements. (They work really well with millions as well.) Usually the speed gains are obvious with about 100 elements, then scale linearly (or worse) as the number increases. I and others use these functions all the time.
One example function writeOpenxlsx()
is a simple wrapper around very useful openxlsx::write.xlsx()
. Also writeOpenxlsx()
applies column formatting for things like P-values, fold changes, log2 fold changes, numeric and integer values – and uses color-shading of cells for each type. So many hours saved from hand-editing Excel formats!
Small and large efficiencies are used wherever possible. For example it is faster to operate on unique entries from a 100,000 element list, than it is to perform a function on the full list. In most cases, I have tested numerous available R methods and packages, and settled on the fastest* available at the time. If there is something faster or better, I would love for you to let me/us know!
The functions in jamba
are intended to be convenient wrappers around whatever series of steps it takes to get the job done. My design goal is to “make my own analysis jobs easier” as first priority.
Lastly, jamba
should motivate me and others to create R packages instead of a random collection of R functions in *.R
files.
mixedSort()
- highly efficient alphanumeric sort, for example chr1, chr2, chr3, chr10, etc.mixedSortDF()
- as above, applied to columns in a data.frame
(or matrix
, tibble
, DataFrame
, etc.)mixedSorts()
- as above, applied to a list of vectors with no speed loss.Example:
| miRNA | sort_rank | mixedSort_rank | |
|---|---|---|---|
| 2 | ABCA2 | 2 | 1 |
| 1 | ABCA12 | 1 | 2 |
| 3 | miR-1 | 3 | 3 |
| 6 | miR-1a | 6 | 4 |
| 7 | miR-1b | 7 | 5 |
| 8 | miR-2 | 8 | 6 |
| 4 | miR-12 | 4 | 7 |
| 9 | miR-22 | 9 | 8 |
| 5 | miR-122 | 5 | 9 |
These functions help with base R plots, in all those little cases when the amazing ggplot2
package is not a smooth fit.
nullPlot()
- convenient “blank” base R plot, optionally displays marginsplotSmoothScatter()
- smooth scatter plot()
for point density, enhanced over smoothScatter()
plotPolygonDensity()
- fast density/histogram plot for vector or matrix
imageDefault()
- enhanced image()
that enables raster output with consistent pixel aspect ratio.imageByColors()
- wrapper to image()
for a matrix or data.frame of colors, with optional labels
minorLogTicksAxis()
- log-transformed axis labels, flexible log base, and option for properly adjusted log2(1 + x)
format.sqrtAxis()
- draw a square-root transformed axis, with proper labels.drawLabels()
- draw square colorized text labelsshadowText()
- replacement for text()
that draws shadows or outlines.
groupedAxis()
- grouped axis labels to show regions/rangesdecideMfrow()
- determine appropriate value for par("mfrow")
for multipanel output in base R plotting.getPlotAspect()
- determine visible plot aspect ratio.Every Bioinformatician/statistician needs to write data to Excel, the writeOpenxlsx()
function is consistent and makes it look pretty. You can save numerous worksheets in a single Excel file, without having to go back and custom-format everything.
writeOpenxlsx()
- flexible Excel exporter, with categorical and conditional colors.applyXlsxCategoricalFormat()
- apply categorical colors to ExcelapplyXlsxConditionalFormat()
- apply conditional colors to ExcelEverything I do uses color to the utmost limit, especially on R console, and in every R plot.
getColorRamp()
- flexible to create or retrieve color gradientswarpRamp()
- “bend” a color gradient to enhance the visual rangecolor2gradient()
- convert a color to gradient of n colors; or do the same for a vectormakeColorDarker()
- adjust darkness and saturationshowColors()
- display a vector or list of colorsfixYellow()
- adjust the weird green-yellow, by personal preferenceprintDebug()
- pretty colorized text output using crayon
package.
Cool methods to operate on super-long lists in one call, to avoid looping through the list either with for()
loops, lapply()
or map()
functions.
cPaste()
- highly efficient paste()
over a large list of vectorscPasteS()
- as above but using mixedSort()
before paste()
.cPasteU()
- as above but using uniques()
before paste()
.cPasteSU()
- as above but using mixedSort()
and uniques()
before paste()
.uniques()
- efficient unique()
over a list of vectorssclass()
- runs class()
on a listsdim()
, ssdim()
- dimensions of list objects, or nested list of listsrbindList()
- efficient do.call(rbind, ...)
to bind rows into a matrix or data.frame, useful when following strsplit()
.mergeAllXY()
- merge a list of data.frame
objectsrmNULL()
- remove NULL or empty elements from a list, with optional replacementWe use R names as an additional method to make sure everything is kept in the proper order. Many R functions return results using input names, so it helps to have a really solid naming strategy. For the R functions that remove names – I highly recommend adding them back yourself!
makeNames()
- make unique names, using flexible logicnameVector()
- add names to a vector, using its own value, or supplied namesnameVectorN()
- make named vector using the names of a vector (useful inside lapply()
) or any function that returns data using names of the input vector.pasteByRow()
- fast, flexible row-paste with delimiters, optionally remove blankspasteByRowOrdered()
- as above but returns ordered factor, using existing factor orders from each column when presentrowGroupMeans()
, rowRmMadOutliers()
- efficient grouped row functionsmergeAllXY()
- merge a list of data.frame
into onerenameColumn()
- rename columns from
and to
.kable_coloring()
- flexible colorized data.frame
output in Rmarkdown.gsubOrdered()
- gsub that returns ordered factor, maintians the previous factor ordergrepls()
- grep the environment (including attached packages) for object namesvgrep()
, vigrep()
- value-grep shortcutunvgrep()
, unvigrep()
- un-grep – remove matched results from the output.provigrep()
- progressive grep, searches each pattern in order, returning results in that orderigrepHas()
- rapid case-insensitive grep presence/absense testucfirst()
- upper-case the first letter of each word.padString()
, padInteger()
- produce strings from numeric values with consistent leading zeros.noiseFloor()
- apply noise floor (and ceiling) with flexible replacement valueswarpAroundZero()
- warp a numeric vector symmetrically around zerorowGroupMeans()
, rowRmMadOutliers()
- efficient grouped row functionsdeg2rad()
, rad2deg()
- convert degrees to radiansrmNA()
- remove NA values, with optional replacementrmInfinite()
- remove infinite values, with optional replacement.formatInt()
- convenient format()
for integer output, with comma-delimiter by defaultjargs()
- pretty function arguments, optional pattern search argument name
jargs(plotSmoothScatter)
#> x = ,
#> y = NULL,
#> bandwidthN = 300,
#> transformation = function( x ) x^0.25,
#> xlim = NULL,
#> ylim = NULL,
#> nbin = 256,
#> nrpoints = 0,
#> colramp = c("white", "lightblue", "blue", "orange", "orangered2"),
#> doTest = FALSE,
#> fillBackground = TRUE,
#> naAction = c("remove", "floor0", "floor1"),
#> xaxt = "s",
#> yaxt = "s",
#> add = FALSE,
#> applyRangeCeiling = TRUE,
#> useRaster = TRUE,
#> verbose = FALSE,
#> ... =
printDebug()
- pretty colorized text output using crayon
package.setPrompt()
- pretty colorized R console prompt with project name and R versionnewestFile()
- most recently modified file from a vector of filesjamma
– MA-plots (also known as “mean-variance”, “Bland-Altman”, or “mean-difference” plots), relies upon jamba::plotSmoothScatter()
; centerGeneData()
to apply flexible row-centering with optional groups and control samples; jammanorm()
- normalize data based upon MA-plot outputcolorjam
– colorjam::rainbowJam()
for scalable categorical colors using alternating luminance and chroma values.genejam
– fast, consistent conversion of gene symbols to the most current gene nomenclaturesplicejam
– Sashimi plots for RNA-seq datamultienrichjam
– multiple gene set enrichment analysis and visualizationplatjam
– platform technology functions, importers for NanoString


nvidia-installer
was inspired by
the loki_update
tool: http://icculus.org/loki_setup/
The self-extracting archive (also known as the .run
file) is generated using makeself.sh
: http://www.megastep.org/makeself/
The version of makeself.sh used to create the .run is bundled within the .run file, and can retrieved by extracting the .run file's contents, e.g.:
$ sh NVIDIA-Linux-x86_64-460.27.04.run --extract-only $ ls -l NVIDIA-Linux-x86_64-460.27.04/makeself.sh
Portions of the NVIDIA OpenCL implementation contain components licensed from third parties under the following terms:
Clang & LLVM:
Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.
All rights reserved.
Portions of LLVM's System library:
Copyright (C) 2004 eXtensible Systems, Inc.
Developed by:
LLVM Team
University of Illinois at Urbana-Champaign
http://llvm.org
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal with the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimers.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimers in the documentation and/or other materials provided with the distribution.
Neither the names of the LLVM Team, University of Illinois at Urbana-Champaign, nor the names of its contributors may be used to endorse or promote products derived from this Software without specific prior written permission.
 IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE SOFTWARE.
The self-installing .run package is compressed using xz, and includes a decompressor built from the xz-embedded project, available at http://tukaani.org/xz/embedded.html.
nvidia-settings uses jansson for parsing configuration files, available at http://www.digip.org/jansson/.
This library carries the following copyright notice:
Copyright (c) 2009-2012 Petri Lehtinen<EMAIL_ADDRESS>Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
The NVIDIA GPU driver uses the lz4 compression algorithm as implemented by the lz4 library, available at https://code.google.com/p/lz4/.
This library carries the following copyright notice:
LZ4 - Fast LZ compression algorithm
Copyright (C) 2011-2013, Yann Collet.
BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

You can contact the author at :
LZ4 source repository : http://code.google.com/p/lz4/
LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c
The libnvidia-ml (NVML) and nvidia-persistenced components rely on libtirpc for communication, available at https://sourceforge.net/projects/libtirpc/.
This library carries the following copyright notice:
Copyright (c) Copyright (c) Bull S.A. 2005 All Rights Reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
The name of the author may not be used to endorse or promote products derived from this software without specific prior written permission.

Portions of the NVIDIA NGX implementation contain components licensed from OpenSSL under the following terms:
Copyright (c) 1998-2019 The OpenSSL Project. All rights reserved.
This product includes software developed by the OpenSSL Project for use in the OpenSSL Toolkit (http://www.openssl.org/)
THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com). All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
All advertising materials mentioning features or use of this software must display the following acknowledgement: "This product includes cryptographic software written by Eric Young (eay@cryptsoft.com)" The word 'cryptographic' can be left out if the routines from the library being used are not cryptographic related :-).
If you include any Windows specific code (or a derivative thereof) from the apps directory (application code) you must include an acknowledgement: "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
The license and distribution terms for any publicly available version or derivative of this code cannot be changed. i.e. this code cannot simply be copied and put under another distribution license [including the GNU Public License.]
Portions of the NVIDIA NGX implementation contain components licensed from libbele under the following terms:
Copyright (c) 2015-2016 David du Colombier
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Portions of the NVIDIA NGX implementation contain components licensed from libelf under the following terms:
Copyright (c) 2016 David du Colombier
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
The NVIDIA NGX Updater implementation contains components licensed from libcurl under the following terms:
COPYRIGHT AND PERMISSION NOTICE
Copyright (c) 1996 - 2020, Daniel Stenberg<EMAIL_ADDRESS>and many contributors, see the THANKS file.
All rights reserved.
Permission to use, copy, modify, and distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of a copyright holder shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization of the copyright holder.
This NVIDIA Linux driver contains code from the X.Org project.
Source code from the X.Org project is available from http://cgit.freedesktop.org/xorg/xserver
The NetBSD implementations of the following compiler intrinsics are used for better portability: __udivdi3, __umoddi3, __divdi3, __moddi3, __ucmpdi2, __cmpdi2, __fixunssfdi, __fixunsdfdi, __ashldi3 and __lshrdi3.
These carry the following copyright notice:
Copyright (c) 1992, 1993 The Regents of the University of California. All rights reserved.
This software was developed by the Computer Systems Engineering group at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and contributed to Berkeley.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
All advertising materials mentioning features or use of this software must display the following acknowledgement: This product includes software developed by the University of California, Berkeley and its contributors.
Neither the name of the University nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

This NVIDIA Linux driver uses a JSON parser based on
jsmn
: http://zserge.bitbucket.org/jsmn.html
This library carries the following copyright notice:
Copyright (c) 2010 Serge A. Zaitsev
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Portions of the driver use the SHA-256 algorithm derived from sha2.c: https://github.com/ouah/sha2/blob/master/sha2.c
This library carries the following copyright notice:
Copyright (C) 2005, 2007 Olivier Gay<EMAIL_ADDRESS>All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
Neither the name of the project nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

This NVIDIA Linux driver contains code from libselinux, which is released in the public domain.
Portions of the driver use the SoftFloat floating point emulation library: http://www.jhauser.us/arithmetic/SoftFloat.html
SoftFloat has the following license terms:
John R. Hauser
2017 August 10
The following applies to the whole of SoftFloat Release 3d as well as to each source file individually.
Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the University of California. All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this list of conditions, and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions, and the following disclaimer in the documentation and/or other materials provided with the distribution.
Neither the name of the University nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.


@* * Copyright 2023 HM Revenue & Customs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @import include._ @import uk.gov.hmrc.thirdpartydeveloperfrontend.domain.models.controllers.Crumb @import uk.gov.hmrc.thirdpartydeveloperfrontend.controllers.routes @this(devMain: DevMainWithFormErrors) @(form: Form[uk.gov.hmrc.thirdpartydeveloperfrontend.controllers.RegisterForm])(implicit request: play.api.mvc.Request[Any], messagesProvider: MessagesProvider, appConfig: ApplicationConfig) @devMain( form, title = "Register for a developer account", isRegistering = true, breadcrumbs = Seq( Crumb.home ), developerSession = None ) {
Register for a developer account to start using our RESTful APIs in your applications. Already registered? Sign in.
You must register separately if you need to work with our XML APIs.
@helper.form(action = routes.Registration.register(), Symbol("class") -> "form js-form") { @helper.CSRF.formFieldBy creating an account you agree to our terms and conditions, privacy policy and cookie policy.
}Already registered? Sign in to your account.
}


Hole:
Par:
Round Score:
Total Score:
created by Noah Vaillancourt the pretty full feature version is here not done yet though :( Soon :D
Disc Keeper is a very simple bare bones score calculator for DiscGolf!
Round Complete!
Par:
Score:
Hole:
Par:
Round Score:
Total Score:
created by Noah Vaillancourt the pretty full feature version is here not done yet though :( Soon :D


Learn about rebasing, and rebase the doc branch onto the master branch
We setup a git repository so that you can train to do git rebase
$ git clone https://github.com/edi9999/git-test-iut.git
We want to see what the git graph looks like. We have multiple solutions for this. To see the commits, you can use one of the multiple git guis (SourceTree, ou SmartGit, ou tig, ou gitk)
Try this command
$ gitk --all
The repository has two branches : master and doc.
As you can see, the doc branch starts on an old commit of master. What rebase does is to change the starting point of a branch, to an other commit. What we want to do here is to set the starting commit of the branch doc to be master.
First, checkout to the doc branch. If you don't remember how to do this, open the page about branches
We want to rebase the branch onto master. To rebase a branch onto another branch, we just have to write
$ git rebase `branch`
where branch is the branch we want to rebase the currently checked out branch
git-it verify
git-it


arrow_back
Sign Up
check
Tip for Profile Pictures
We strongly recommend you to use a square image, preferrably a 500px by 500px one.
add_a_photo
person
First Name
Last Name
account_balance
Branch
call
Mobile Number
email
Email
school
RGPV Enrollment Number
lock
Password


What are three new things you have learned about yourself and your ego as a result of the core learning?
I think that my ego often tries to discourage me. Often at the start of a challenge, I would feel overwhelmed and feel like I wouldn’t be able to do it. Then I would surprise myself during the challenge. I think that this is something I need to be aware of and to step up to challenges and say yes to them rather than not attempting something because I feel like I won’t be able to do it.
I also learned that I can often feel frustrated when I can’t figure something out straight away. I think I am not that great at delayed gratification, I want to figure something out as quickly as possible and get the buzz from that. However, the times I really got stuck but kept with it and eventually solved the problem felt really amazing with a great sense of achievement.
My ego also often doesn’t like to self reflect! I have often felt a lot of resistance to self-reflection and thinking about what I’m good at and what I need to improve upon. I think it is really hard to be 100% honest with yourself but I am going to keep trying because I think it is a really important skill.
What are the role of values, empathy and self awareness in learning and programming?
I think self-awareness is really, really important in learning so we can reflect critically on what we are doing and see what patterns we are getting stuck in, what we are doing well and what we can improve upon. Empathy is important so we can be kind and friendly to ourselves as well as others when we are learning. Programming is hard and can often be frustrating so when we are feeling stuck it is really important to be kind to ourselves and I think when we can be kind to ourselves we will also be kind to others. I think values are important because they really help give us a sense of meaning and purpose in life that is not dependent on our work or family. We really need to know why we are doing the things we do and what sort of values we want to contribute to the world to hopefully make the world a better place.
What has surprised you the most about the core learning?
What has surprised me the most is how helpful all the core learning practices are in learning how to be a more effective learner. I especially found the self-reflection to be helpful in figuring out what I am doing well and what I need to improve upon.
What were the most challenging aspects of the core learning?
I found genuine and honest self-reflection to be one of the most challenging parts! I feel like my ego often wants to try and present a perfect version of me and is resistant to reflecting on my flaws and what I need to improve.
Why do you think we, a programming school, are spending so much time focusing on core learning in a web development bootcamp course?
Because our emotions and feelings and what we think affects so much of what we do and how we behave in the world. It’s really important to be able to understand ourselves and our emotions and have a sense of purpose and meaning in life and this helps us to learn and work much more effectively.
Does the time you spent studying core learning here feel like a waste of time? Should you have just used that time to practising programming instead? Justify your answer.
No, it definitely hasn’t felt like a waste of time! I feel like the core learning program and especially self-reflection will help me to be a much better learner and a better person in life!


The most effective engineers (and leaders) are curious humans — scientists, even if they don’t know it — and they’re always, always asking questions, formulating hypotheses, running experiments.
Certificate of Merit in Computer Science by CBSE.
Select in CSRL GAIL Utkarsh Super 100.
Contributed to Tensorflow, Circuit Verse etc..
It is our choices, that shows what we truly are, far more than our abilites.
We will provide an android based online testing platform which can be used to conduct tests wrapped with all necessary precautions to reduce the chances of cheating. Here the educator will can create classes and test on web portal and all the questions will be randomly distributed among the students resulting in large number of sets.
FeaturesA series of minor projects using Machine Learning and scikti-learn.
“Try never to be the smartest person in the room. And if you are, I suggest you invite smarter people… or find a different room.” Always choose an opportunity to learn, to grow new skills.
B.tech CSE
2019 - Presentcgpa: 8.13
spga: 8.38
XII th
2016 - 17Marks: 88%
X th
2014 - 15cgpa: 9.4
If you can’t communicate your findings or collaborate with others, your career will be over before it begins. Science and engineering are team sports. Any successful open-source project will have a strong emphasis on communication, collaboration, empathy, and respect - not just engineering.


{{claimantSO.claimantAddresses | optAddressPipe}}
Username:
Placeholder username
Email Address:
{{claimantSO.email}}
Date of Birth:
{{claimantSO.dateOfBirth | optDatePipe}}
Alternate Claimant ID:
{{claimantSO.alternateClaimantId}}
Mobile Phone:
{{claimantSO.mobilePhone | optPhonePipe}}
Preferred Payment:
Placeholder preferred payment


This demo shows the ability to clone multiple form elements at the same time (or a section of a form.) For cloning multiple subcomponents of a form independently see other demo.
This field is required.
add section remove section above
Submit


Set Data for my shutdown timer :
Hours
Please , make sure to enter the number of hours ..
Minutes
Please , make sure to enter the number of hours ..
Seconds
Please , make sure to enter the number of hours ..
SET TIMER
Start Clock
Stop Clock
Reset Clock


A Little Romance (1979)
Grade: 59
While on a field trip with schoolmates to a movie studio in France, Daniel (Thelonious Bernard) meets Lauren (Dianne Ladd), who has been taken there by actress Kay King (Sally Kellerman). Both Bernard and Ladd are barely into their teens, and they have something else in common: they're very smart and virtually friendless. They connect, and begin arranging furtive dates behind their parents' back.
For Ladd's birthday, a party for her has long been arranged. But her own mother forgets about this and gives a wrap party for her latest picture on the same day. Ladd and her friends, one of whom is Bernard, are relegated to her room, which is just as well since they evade parental supervision, drink champagne, and dance closely. Leaving her room, Bernard runs into the jerk director, who makes a public snide remark about his scoring with Ladd. Bernard punches the director in the stomach and demands an apology. This puts Bernard on Kellerman's blacklist, and Ladd is told she cannot see him again. Which she does anyway.
Kellerman has been married three times. Current husband Richard (Arthur Hill) is patient but still frustrated with her cavorting with her latest film's director. Good news (for him) comes when his company informs him that he will be transferred from France to Houston at the end of the month. Kellerman isn't happy about the coming move. Even less so is Ladd.
While hanging in the park, Bernard accidentally knocks down an elderly gentleman (Laurence Olivier). Bernard and Ladd help him up and are then treated to lunch, with Olivier telling lies and tall tales to impress them. Ladd believes the stories, but more worldly Bernard is suspicious.
One of Olivier's stories is that lovers who kiss in a gondola in a Venice under a certain bridge at sunset when church bells are tolling will love each forever. Ladd takes this story to heart and becomes obsessed at fulfulling this destiny with Bernard.
Tbey need money for the trip, and go to the racetrack with Olivier to win it. Bernard's horse loses the race, but Olivier switches bets and wins big. (It turns out that Olivier is a con artist and pickpocket, and he stole the money).
Olivier, for some reason interested in getting himself and his new friends in endless trouble for the sake of a first crush, helps Bernard and Ladd run away from home, putting them on a train to Italy. The kid's parents get wind of the scheme and go to Italy to retrieve them. Ladd's pretty face is in the newspaper as a missing child. To avoid capture, Bernard, Ladd and Olivier join a bicycle race, which appears to be a plot device to have Olivier crash his bike.
Bernard and Ladd after some further difficulty manage to kiss in a gondola under that bridge at sunset with the church bells tolling. Olivier and the lovesick teens are caught and return to France. On the day that Ladd must return to the states, Ladd sees Bernard and Olivier (who curiously is not in jail) and has a tearjerker parting.
http://members.tripod.com/~Brian_Koller/movies.html
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


Man United prepare offer for 19-year-old Norwegian striker – report
Man United manager Ole Gunnar Solskjaer tells the Red Devils how much to offer for Erling Braut Haaland, according to a report
by Transfer AgentManchester United are preparing an offer for Red Bull Salzburg striker Erling Braut Haaland, according to a report in Norway.
Norwegian media outlet Dagbladbet, as quoted by Metro, is reporting that Manchester United manager Ole Gunnar Solskjaer is a big admirer of the Salzburg forward.
The same article states that Solskjaer has instructed Manchester United to push ahead with their plans to sign the 19-year-old after working with Haaland during his stint at Molde.
According to the same story, the Red Devils boss has informed the Manchester United board how much he believes they should pay for Haaland ahead of the January transfer window.
The report goes on to suggest that Manchester United are now the favourites to sign Haaland in a big-money deal.
Manchester United will more than likely have to wait until the summer to recruit Haaland as Salzburg are unlikely to want to sell the striker in January given their hunt for silverware this term, the story concludes.
The Red Devils sold Romelu Lukaku to Inter Milan in the summer transfer window before Alexis Sanchez followed the Belgian striker to the San Siro on a season-long loan deal.
Solskjaer’s squad is threadbare in forward positions as the Manchester United manager continues to rely on Anthony Martial, Marcus Rashford and Mason Greenwood up front.


TOMBSTONE A film review by Scott Renshaw Copyright 1994 Scott Renshaw
Starring: Kurt Russell, Val Kilmer, Michael Biehn, Sam Elliott, Bill Paxton, Dana Delaney, Powers Boothe, Stephen Lang. Screenplay: Kevin Jarre. Director: George P. Cosmatos.
After a few decades when Westerns were about as easy to find as Jimmy Hoffa, it seems like you can't sneeze at the movies these days without hitting a horse. The success of DANCES WITH WOLVES and UNFORGIVEN has inspired a whole herd of giddyap yarns. In 1993 we've already seen POSSE and GERONIMO: AN AMERICAN LEGEND, and now comes the first of two Wyatt Earp projects set to hit theaters in a six month span (a Lawrence Kasdan/Kevin Costner project is due in late spring). TOMBSTONE is the name, ma'am, and surprisingly lively entertainment is the game. While no great piece of art, TOMBSTONE is a real old-fashioned shoot-em-up, energetically staged and acted and featuring a particularly memorable performance from Val Kilmer.
TOMBSTONE opens in 1879 as Wyatt Earp (Kurt Russell) arrives in Tombstone, Arizona to join brothers Virgil (Sam Elliott) and Morgan (Bill Paxton). Although a legendary lawman in Kansas, Wyatt insists he's retired, content to run a small casino in the booming mining town. However, peace and quiet are not in the cards for the Earps. The wild and violent Cowboys, led by Curly Bill (Powers Boothe) and Johnny Ringo (Michael Biehn), hold Tombstone in a perpetual state of lawlessness, and eventually the violence escalates into the legendary showdown at the OK Corral, with the Earps and gambler Doc Holliday (Val Kilmer) facing a group of Cowboys including Ike Clanton (Stephen Lang). But even that battle is not the end, as Tombstone becomes the nexus of a blood feud which won't end until one side or the other is completely dead.
Director George P. Cosmatos is best known for the ultra-violent RAMBO, and TOMBSTONE shows many similarities. There is a great deal of montage-style violence, and an armory full of bullets fired. It's action that TOMBSTONE is about first and foremost, and it delivers big time. There are few slow stretches, and they usually build towards something. The big shootout at the OK Corral might be the least effective of the action pieces; it's edited in a fairly confusing fashion which may accent the chaos of the situation but doesn't always make it clear who's shooting whom. Otherwise the action is extremely well-choreographed, backed up by a Bruce Broughton score a bit too reminiscent of his work on SILVERADO.
Fortunately, the action is where the comparisons to RAMBO end. TOMBSTONE is well-acted by its ensemble cast, in spite of the most distracting (if authentic) facial hair this side of GETTYSBURG. Kurt Russell, never the most versatile of leading men, does bring an intense and reluctant heroism to Wyatt. He's particularly good in a couple of scenes where he uses his reputation to force other men to back down, burning holes in them with his eyes. Sam Elliott and Bill Paxton are a bit more wooden in less-developed roles, but for the stoic and civic-minded Earps it's not a distraction. The lead Cowboys are uniformly good, notably Stephen Lang as the cowardly Ike Clanton and Michael Biehn as the icy Johnny Ringo. However, the real star of TOMBSTONE is Val Kilmer, who has a devilishly wonderful time with the acerbic, sickly Doc Holliday. Sure, his lines are campy and anachronistic, but they are also quite funny. He drawls out his quips with a sly confidence, and turns in probably his best all-around performance yet.
TOMBSTONE's one glaring misstep is spending any time at all on the relationship between Wyatt and a traveling actor played by Dana Delaney. Delaney is lovely, but her character is just a distraction (as, unfortunately, are all of the female characters in TOMBSTONE), never adding anything in particular to the story or to Wyatt's character. Their scenes together seem simply to be a nod to the conventional wisdom that you need a love story to get women into the theater. While it's spending time wandering through the flowers, TOMBSTONE is nothing special, but when it sticks to its guns it generally finds its target.
On the Renshaw scale of 0 to 10 shootouts: 7.
-- Scott Renshaw Stanford University Office of the General Counsel
.
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


Only displays when you're currently listening to music. Update "username" in JavaScript with your Last.fm username.


While graph interaction networks achieve exceptional results in Higgs boson identification, GNN explainer methodology is still in its infancy. To introduce GNN interpretation to the particle physics domain, we apply layerwise relevance propagation (LRP) to our existing Higgs boson interaction network (HIN) to calculate relevance scores and reveal what features, nodes, and connections are most influential in prediction. We call this application HIN-LRP. The synergy between the LRP interpretation and the inherent structure of the HIN is such that HIN-LRP is able to illuminate which particles and particle features in a given jet are most significant in Higgs boson identification. The resulting interpretations are ultimately congruent with extant particle physics theory, with the model demonstrably learning the importance of concepts like the presence of muons, characteristics of secondary decay, and salient features such as impact parameter and momentum.
Intro
Graph neural networks (GNN) are notoriously difficult to interpret, and those employed in the particle physics domain are no different. The interaction network has gained popularity with high energy physicists studying fundamental particles because this graph model achieves a highly competitive accuracy, while still working with relatively simple and unprocessed data. However, both broadly and in the physics domain, it is often not fully understood how or why the graph interaction networks make their classifications. Layerwise Relevance Propagation is the method we've chosen to use to investigate how these models' inner workings might relate to the physical properties of the universe.
The Higgs boson is a particle that was hypothesized in 1964 by Peter Higgs, and is essentially suggested to represent a universal field that is responsible for the property of mass. Big deal, right? But it took decades before it was actually confirmed. Evidence finally appeared in 2012, at the Large Hadron Collider (LHC), where scientists slam particles together really really fast to make other particles, rare and important particles like the Higgs boson. But even with the particle collider constantly firing, a Higgs event is hard to come by. Not only that, these detectors don’t get to pick up a literal Higgs boson, because it exists for only a brief moment in time before decaying. The detector has to look at the decays, which come in the form of particle jets, and deduce whether or not a Higgs boson event was responsible. Fittingly, these particle jets are the basis of our data.
Particle Jet Data
Context on these "jets", and our data. When a spray of particles hit the detector, the particle flight pathways and measurements are reconstructed into what are called tracks, and then grouped under cone-like clusters. But for the purposes of the model, it's good to know that we actually train on simulation data. Why? Because in quantum physics, we can only predict things probabilistically, so there is no way to confidently label real LHC data. We can say “oh, this was probably a Higgs boson,” but there’s no way of really fully knowing.
So instead, the simulation constructs our data on a fully ground up basis, building off of physics rules that have been theorized and confirmed. A benefit of this is that we can also lessen the rarity of the Higgs boson signal, so that it’s actually useful to train this model. In the simulated dataset, every entry is an individual jet, and each jet can have a variable number of particles, from as little as only 2 tracks to more than 60. For each jet we’ve isolated 48 features, features like momentum, mass, angle...ultimately, the goal is to look at a jet, and say whether it came from a Higgs signal, or is simply background.
The Signal: H to bb
There is a specific Higgs decay that we are looking for: the Higgs Boson decaying into a pair of b hadrons. There are several other permutations of higgs decay that can occur but H to bb is the most common. For the sake of simulation, we have this heavy artificial particle X, which decays into a pair of Higgs bosons, each of which decay into pairs of b hadrons.
To make things tougher, a given jet wouldn’t only have b hadrons, it’d also be full of other particles from adjacent and related decays. It’s altogether quite chaotic, which is why the classification problem in question is one suited for machine learning.
The Higgs Boson Interaction Network Model
That brings us to the Higgs Boson Interaction network, or HIN. This deep learning model finds pretty desirable success for the problem of Higgs boson identification. See this paper.
Interactions networks are a kind of Graph Neural Net. As its name suggests, the interaction network excels at modeling the interaction of objects in complex systems. For the inputs, we take the simulated data and regroup it into a complete directed graph where every node is a particle, with the 48 feature values grouped by particle under the node, and every edge represents a directional relationship between particles.
Why do we represent the jets as graphs? Remember: a jet is a cluster of particles, and there is no inherit ordering of those particles. So graph models are desirable in that they reflect the absence of an inherit ordering. Even better, by fully connecting the graph, we are laying a truth for the model to understand. These particles are all connected in some way, they come from the same collisions, primary decays, maybe even the same secondary decays. It is then just up to model training to decide how connected they are and how important those connections are to determining whether it is a Higgs signal.
We built the model in PyTorch Geometric, which really helps facilitate a lot of the graph connections and the training structure. The core part of the HIN is the interaction block. The interconnectedness of this interaction block allows us to model the flow of information between nodes, or pairs of particles. PyTorch Geometric’s MetaLayer function abstracts a lot of this interconnectedness for us. Note how when the new edge hidden features are calculated, they influence the new node hidden features and global hidden features, and likewise when new node features are calculated, and so on.
Each block is encoded with its respective transformation sequences: concatenations, linear transformations, batch normalizations, and ReLU activations. Our fully trained model will pass the input data through these blocks and return a softmaxed probability of how likely a jet is to be a Higgs boson signal.
But most importantly here’s how it performs: a lovely 99% ROC AUC! Compared to a straightforward boosted decision tree, our interaction network AUC boundary is nearly a right angle, which is quite ideal!
So we have this model, with a pretty splendid accuracy. But we don’t automatically understand how or why the model comes to these conclusions. This is where LRP comes in:
Layerwise Relevance Propagation
LRP is a technique that has found use in interpreting several other neural networks, particularly image convolutional neural networks. More recently, its potential for GNN explanation is being discovered. Like water in a forking river, we branch across the model pathways, distributing relevance scores throughout each layer, all the way back to the inputs. In simple words, we want to use LRP to find out how relevant each part of the input is to the output. So we take our input matrix, use some LRP magic, and for every value in the input, we get a corresponding score telling us how relevant it is the the output.
For our model, this means that LRP allows us to interpret model behavior on a jet by jet basis. Recall that the IN takes a jet as input, and outputs a Higgs boson likelihood for that jet. Here, we will reverse this process using LRP: input the Higgs boson likelihood, and in return we find out which particles, edges, even features of that jet input were most relevant.
Now, you might have realized that LRP is very similar to a regular back-propagation of the model, except that it is propagating the relevance score. It operates on a gradient times input—essentially a Taylor expansion based calculation used to get relevancy at each layer.
Look at this diagram. Follow the color density from the output as it moves backwards through the nodes. The more “relevant” nodes get more weight, and therefore color. For our model, this will allow us to highlight relevancy for both nodes, and edges.
Now for the equation we’re using to propagate relevance: The LRP-ε rule. The complicated math equation defined above is used at each layer to propagate relevance through the model. The rule is derived from the gradient times input concept, with the addition of one more element: The ε refers to a small quantity added to the denominator. With this, we avoid numerical instabilities, and also absorb some of the relevance score such that only the most important features are highlighted.
For the more mathematically inclined, see the LRP page for more a more in depth breakdown.
Dummy Model
To test our LRP, we made fake data, and labeled it using an equation such that the only important features were 0 and 3. Everything else is useless noise.
How do we read this map? The relevance scores are visualized in this heatmap, which has the same dimensions as the input. Each cell in the heatmap corresponds to an entry in the raw input, and it lights up if the entry is relevant to the final prediction. Positive or negative, the brighter the color, the more relevant it is to the prediction. The columns correspond to the 48 features whereas the rows correspond to the 10 tracks in the dummy jet.
So clearly feature 3 is aggressively activated. You may be wondering why feature 0 is blank. We actually saw this result and circled back to our label equation, realizing that even though both feature 0 and 3 are in the equation, only feature 3 mattered to the label. And LRP realized that before we did! So it’s quite funny how this slight error in the construction of our sanity check actually exposed a deeper truth about the dummy data, which honestly just makes us more confident in the validity of the method.
Visualizing Relevance with HIN-LRP
We’ll be looking at four example jets and diving into how LRP interprets each. For each jet, we’ve created a pair of plots to visualize what our model sees for each jet, and what possibly led to the prediction made.
The heatmap on the left looks familiar right? It’s mostly the same as the one we showed with the dummy input example. Here, the heatmap is transposed to give an easier view of the 48 features. Each row corresponds to one feature, and each column now corresponds to a track in the jet, sorted by the top row track_pt, aka transverse momentum, in ascending order. Transverse momentum is known to be an important indicator of whether the jet is associated with Higgs boson. The more intense the color in a cell the more relevant that entry of the input is to the Higgs probability output. Note that the signs of the relevance scores don’t correspond to positive or negative Higgs signal labeling. Only the magnitude matters.
To give a better idea of what our model sees in a jet, we also visualize the significance of the nodes and edges in 3D space, as shown on the right. The 3D network plot projects "polaresque" coordinates φ and η (track_phirel, track_etarel) on the xy plane, and sets the z axis to momentum (again), allowing a clearer view of the dense graph representation of the jet, as well as easy comparison to the heatmap. The sizes of the nodes are determined by node relevance scores, and the edge coloring is determined by their significance in the prediction. The edge significance is a positive, calculated value defined intuitively by the amount of information that flow through it. We can elaborate on the mathematical definition later if you’re interested. The edges receive a positive value between 0 to 1, and in the 3D network plot, the most important edges are highlighted in red.
Let's look at some examples, where the heatmap is interactive so we can see feature values. The library of feature definitions can be found here.
EXAMPLE 1: 99.94% Higgs Boson Signal
In this example, the HIN is more than 99.9% confident in its prediction. The colored cells are mostly distributed in columns 14 and 21, suggesting that those two particles are most relevant to the prediction.
The Higgs boson decays into two b hadrons, right? Our heatmap implies that the model can perceive the two pronged nature of Higgs bosons decaying into the b hadron pair. Additionally, note how the highest momentum node is the most important, and in the 3D space we see the edge connecting to this node to be highly activated. Physicists have shown that Higgs boson decay products are likely to have larger transverse momentum values.
EXAMPLE 2: 99.93% Higgs Boson Signal
Here’s another example output of our HIN-LRP. Like in the previous example, the model is very confident that this jet is a Higgs boson signal. Compared to the heatmap in the previous example, this one displays an even more extreme relevance focus along just two columns, again alluding to the two pronged decay into b hadrons.
Those two particles are the most significant nodes in the prediction, something that is clearly affirmed in corresponding 3D plot on the right. Notably, it is the lower momentum tracks in this jet that are more responsible for classification, but even in this situation momentum itself is still a highly relevant feature, as you can see in the blue cell in particle 1. This time the HIN also made its prediction with positional information in addition to the momentum data in feature trackBTag_PtRel, highlighted in blue. The bright red cells at trackBTag_EtaRel relates to the track’s location in space; track_VTX_ass and track_fromPV are related to its closeness to the primary vertex.
EXAMPLE 3: 99.88% Higgs Boson Signal
This higgs boson jet is one of the first to get us excited about HIN-LRP’s ability to reveal the model’s relationship to physics.
If we draw our attention to the feature track_isMu, aka “is this particle a muon”, we'd see that track 19 is indeed a muon. As that super blue square indicates, the muon track is extremely important information when it comes to the model’s classification. This is great because it reflects real physics phenomena: muons are actually relatively common outputs of b hadron decay. And if b hadrons are decaying, there’s a good chance those b hadrons were descended from a Higgs boson signal. It’s promising that our model has gleaned the importance of the muon, and shows that the HIN is able to learn physics rules from the chaotic collision events, and that LRP is able to illuminate the HIN’s understanding in this manner.
EXAMPLE 4: 99.95% Higgs Boson Signal
In this last example, the heatmap conveys two core pieces information about our model’s decision.
In track 19, many cells are highly activated, which indicates that the model utilized a host of positional information like momentum from feature track_pt, angle from the jet axis from track_deltaR, track_etarel, and angle from the secondary vertex track_drminsv. Alongside this positional information in track 19 is the boolean for feature track_puppiw, which indicates whether the track is "pileup-like", or more colloquially, an intrusive track from a separate jet decay. This indicates that our model understands that all that other positional information is only helpful given that this track is actually native to this jet.
The other important cell is the bright red cell in track 18 under track_isEl, or "track is electron". Electrons are leptons, like muons, and also emerge in the decay of b hadrons at a significant rate. So, this particle feature, together with all the other information from track 19, is a strong indicator of the jet being related to a Higgs boson when present.
Conclusion
We presented a specific way to interpret the inner workings of the Higgs boson interaction network through layerwise relevance propagation, and have found that our methodology does, to a significant extent, reflect the foundations of theoretical physics that the model is trained on.
This is not the only way to visualize the outputs of layerwise relevance propagation, this is not the only way to implement layerwise relevance propagation, and LRP is not even the only way to approach interpreting this type of model. What this is, however, is one of the first forays into utilizing GNN interpretation in the particle physics domain.
We can now successfully understand how the HIN makes decisions on a jet by jet level in a way that was not explored before. As GNN explanation is constantly innovating, the tactics we have outlined can be further refined alongside the latest methodologies—varied LRP rules, generalized heuristics, relevant walks—to reach an even deeper understanding of how deep learning comes to understand the laws of physics.
Photograph from HDWallsbox.


Zend Framework
LICENSE
This source file is subject to the new BSD license that is bundled with this package in the file LICENSE.txt. It is also available through the world-wide-web at this URL: http://framework.zend.com/license/new-bsd If you did not receive a copy of the license and are unable to obtain it through the world-wide-web, please send an email to<EMAIL_ADDRESS>so we can send you a copy immediately.
Zend_Soap_Server
array
$_classArgs= 'array'
Arguments to pass to {@link $_class} constructor
array
Detailsarray
$_classmap= ''
Array of SOAP type => PHP class pairings for handling return/incoming values
array|int
$_functions= 'array'
Functions registered with this server; may be either an array or the SOAP_FUNCTIONS_ALL constant
array
Detailsint
$_persistence= ''
Persistence mode; should be one of the SOAP persistence constants
boolean
$_returnResponse= 'false'
Flag: whether or not {@link handle()} should return a response instead of automatically emitting it.
false
Detailsint
$_soapVersion= 'SOAP_1_2'
SOAP version to use; SOAP_1_2 by default, to allow processing of headers
SOAP_1_2
Details__construct(
string $wsdl
=
null, array $options
=
null
)
:
void
Constructor
Sets display_errors INI setting to off (prevent client errors due to bad XML in response). Registers {@link handlePhpErrors()} as error handler for E_USER_ERROR.
If $wsdl is provided, it is passed on to {@link setWsdl()}; if any options are specified, they are passed on to {@link setOptions()}.
| Name | Type | Description |
|---|---|---|
| $wsdl | string | |
| $options | array |
_getSoap(
)
:
\SoapServer
Get SoapServer object
Uses {@link $_wsdl} and return value of {@link getOptions()} to instantiate SoapServer object, and then registers any functions or class with it, as well as peristence.
| Type | Description |
|---|---|
| \SoapServer |
_initializeSoapErrorContext(
)
:
boolean
Method initalizes the error context that the SOAPServer enviroment will run in.
| Type | Description |
|---|---|
| boolean | display_errors original value |
_setRequest(
\DOMDocument|\DOMNode|\SimpleXMLElement|\stdClass|string $request
)
:
\Zend_Soap_Server
Set request
$request may be any of: - DOMDocument; if so, then cast to XML - DOMNode; if so, then grab owner document and cast to XML - SimpleXMLElement; if so, then cast to XML - stdClass; if so, calls __toString() and verifies XML - string; if so, verifies XML
| Name | Type | Description |
|---|---|---|
| $request | \DOMDocument|\DOMNode|\SimpleXMLElement|\stdClass|string |
| Type | Description |
|---|---|
| \Zend_Soap_Server |
addFunction(
array|string $function, string $namespace
)
:
\Zend_Soap_Server
Attach a function as a server method
Namespacing is primarily for xmlrpc, but may be used with other implementations to prevent naming collisions.
| Name | Type | Description |
|---|---|---|
| $function | array|string | Function name, array of function names to attach, or SOAP_FUNCTIONS_ALL to attach all functions |
| $namespace | string | Ignored |
| Type | Description |
|---|---|
| \Zend_Soap_Server |
| Exception | Description |
|---|---|
| \Zend_Soap_Server_Exception | on invalid functions |
deregisterFaultException(
string $class
)
:
boolean
Deregister a fault exception from the fault exception stack
| Name | Type | Description |
|---|---|---|
| $class | string |
| Type | Description |
|---|---|
| boolean |
fault(
string|\Exception $fault
=
null, string $code
=
Receiver
)
:
\SoapFault
Generate a server fault
Note that the arguments are reverse to those of SoapFault.
If an exception is passed as the first argument, its message and code will be used to create the fault object if it has been registered via {@Link registerFaultException()}.
| Name | Type | Description |
|---|---|---|
| $fault | string|\Exception | |
| $code | string | SOAP Fault Codes |
| Type | Description |
|---|---|
| \SoapFault |
getFunctions(
)
:
array
Return a server definition array
Returns a list of all functions registered with {@link addFunction()}, merged with all public methods of the class set with {@link setClass()} (if any).
| Type | Description |
|---|---|
| array |
getOptions(
)
:
array
Return array of options suitable for using with SoapServer constructor
| Type | Description |
|---|---|
| array |
getPersistence(
)
:
\Zend_Soap_Server
Get server persistence
| Type | Description |
|---|---|
| \Zend_Soap_Server |
handle(
\DOMDocument|\DOMNode|\SimpleXMLElement|\stdClass|string $request
=
null
)
:
void|string
Handle a request
Instantiates SoapServer object with options set in object, and dispatches its handle() method.
$request may be any of: - DOMDocument; if so, then cast to XML - DOMNode; if so, then grab owner document and cast to XML - SimpleXMLElement; if so, then cast to XML - stdClass; if so, calls __toString() and verifies XML - string; if so, verifies XML
If no request is passed, pulls request using php:://input (for cross-platform compatability purposes).
| Name | Type | Description |
|---|---|---|
| $request | \DOMDocument|\DOMNode|\SimpleXMLElement|\stdClass|string | Optional request |
| Type | Description |
|---|---|
| voidstring |
handlePhpErrors(
int $errno, string $errstr, string $errfile
=
null, int $errline
=
null, array $errcontext
=
null
)
:
void
Throw PHP errors as SoapFaults
| Name | Type | Description |
|---|---|---|
| $errno | int | |
| $errstr | string | |
| $errfile | string | |
| $errline | int | |
| $errcontext | array |
| Exception | Description |
|---|---|
| \SoapFault |
loadFunctions(
$definition
)
:
void
Unimplemented: Load server definition
Used for persistence; loads a construct as returned by {@link getFunctions()}.
| Name | Type | Description |
|---|---|---|
| $definition |
| Exception | Description |
|---|---|
| \Zend_Soap_Server_Exception | Unimplemented |
registerFaultException(
string|array $class
)
:
\Zend_Soap_Server
Register a valid fault exception
| Name | Type | Description |
|---|---|---|
| $class | string|array | Exception class or array of exception classes |
| Type | Description |
|---|---|
| \Zend_Soap_Server |
setActor(
string $actor
)
:
\Zend_Soap_Server
Set actor
Actor is the actor URI for the server.
| Name | Type | Description |
|---|---|---|
| $actor | string |
| Type | Description |
|---|---|
| \Zend_Soap_Server |
setClass(
string $class, $namespace, $argv
=
null
)
:
\Zend_Soap_Server
Attach a class to a server
Accepts a class name to use when handling requests. Any additional arguments will be passed to that class' constructor when instantiated.
See {@link setObject()} to set preconfigured object instances as request handlers.
| Name | Type | Description |
|---|---|---|
| $class | string | Class Name which executes SOAP Requests at endpoint. |
| $namespace | ||
| $argv |
| Type | Description |
|---|---|
| \Zend_Soap_Server |
| Exception | Description |
|---|---|
| \Zend_Soap_Server_Exception | if called more than once, or if class does not exist |
setClassmap(
array $classmap
)
:
\Zend_Soap_Server
Set classmap
| Name | Type | Description |
|---|---|---|
| $classmap | array |
| Type | Description |
|---|---|
| \Zend_Soap_Server |
| Exception | Description |
|---|---|
| \Zend_Soap_Server_Exception | for any invalid class in the class map |
setEncoding(
string $encoding
)
:
\Zend_Soap_Server
Set encoding
| Name | Type | Description |
|---|---|---|
| $encoding | string |
| Type | Description |
|---|---|
| \Zend_Soap_Server |
| Exception | Description |
|---|---|
| \Zend_Soap_Server_Exception | with invalid encoding argument |
setObject(
object $object
)
:
\Zend_Soap_Server
Attach an object to a server
Accepts an instanciated object to use when handling requests.
| Name | Type | Description |
|---|---|---|
| $object | object |
| Type | Description |
|---|---|
| \Zend_Soap_Server |
setOptions(
array|\Zend_Config $options
)
:
\Zend_Soap_Server
Set Options
Allows setting options as an associative array of option => value pairs.
| Name | Type | Description |
|---|---|---|
| $options | array|\Zend_Config |
| Type | Description |
|---|---|
| \Zend_Soap_Server |
setReturnResponse(
boolean $flag
)
:
\Zend_Soap_Server
Set return response flag
If true, {@link handle()} will return the response instead of automatically sending it back to the requesting client.
The response is always available via {@link getResponse()}.
| Name | Type | Description |
|---|---|---|
| $flag | boolean |
| Type | Description |
|---|---|
| \Zend_Soap_Server |
setSoapVersion(
int $version
)
:
\Zend_Soap_Server
Set SOAP version
| Name | Type | Description |
|---|---|---|
| $version | int | One of the SOAP_1_1 or SOAP_1_2 constants |
| Type | Description |
|---|---|
| \Zend_Soap_Server |
| Exception | Description |
|---|---|
| \Zend_Soap_Server_Exception | with invalid soap version argument |
setUri(
string $uri
)
:
\Zend_Soap_Server
Set URI
URI in SoapServer is actually the target namespace, not a URI; $uri must begin with 'urn:'.
| Name | Type | Description |
|---|---|---|
| $uri | string |
| Type | Description |
|---|---|
| \Zend_Soap_Server |
| Exception | Description |
|---|---|
| \Zend_Soap_Server_Exception | with invalid uri argument |
setWsdl(
string $wsdl
)
:
\Zend_Soap_Server
Set wsdl
| Name | Type | Description |
|---|---|---|
| $wsdl | string | URI or path to a WSDL |
| Type | Description |
|---|---|
| \Zend_Soap_Server |
validateUrn(
string $urn
)
:
true
Check for valid URN
| Name | Type | Description |
|---|---|---|
| $urn | string |
| Type | Description |
|---|---|
| true |
| Exception | Description |
|---|---|
| \Zend_Soap_Server_Exception | on invalid URN |