Phaser 1.1.4
Phaser is a fast, free and fun open source game framework for making desktop and mobile browser HTML5 games. It uses Pixi.js internally for fast 2D Canvas and WebGL rendering.
Version: 1.1.4 "Kandor" - Released: February 5th 2014
By Richard Davey, Photon Storm
- View the Official Website
- Follow on Twitter
- Join the Forum
- Try out 220+ Phaser Examples
- Read the documentation online
Subscribe to our new Phaser Newsletter. We'll email you when new versions are released as well as send you our regular Phaser game making magazine.
Welcome to Phaser
As you may know we had planned to release 1.1.4 at the end of 2013. For various reasons this didn't quite happen, but we're happy to announce it's finally out! There have been some dramatic changes internally, and if you make use of either the physics systems or tilemaps then you are going to need to update your code. Hopefully only a little bit, but there have been a number of core API changes which we detail below. There are also a host of new features, the headliners being:
- New Physics system. Uses SAT.js internally so physics bodies can now be rectangles, circles or polygons and support rotation.
- New Tilemap system. Brand new collision system for tiles, much more advanced layer handling, tile properties, multiple tilesets of layer and more.
- New Timer. This handy new class lets you create timed events easily.
- Your Game can now be configured from an external configuration object.
- Over 150 new features and updates and over 30 reported bug fixes.
This release also brings the TypeScript definitions file as bang up to date as possible. There are still a few areas that need looking at, but with your help hopefully we can iron those final few bits out and have a 100% accruate defs file on offer.
There is a new Contributors Guide which we'd urge you to follow if you wish to help with Phaser development, and we've updated the doc files and added lots more details into key areas. The Examples have grown too! Now over 220 of them including several great ones from the community.
We're going to settle on this build for a short while as we do some quick iteration bug fixing, so expect to see some small point releases very soon that do nothing but address any issues you may find. But in parallel to this we are also now rebuilding our core to bring it in-line with the latest version of Pixi.js, which has had some dramatic changes under the hood, changes will impact a lot of what Phaser does internally. But the changes are all for the better and once we upgrade Pixi you'll have a significantly faster renderer and a smaller codebase too, as we do away with stacks of linked list code :)
As always we offer a heart-felt "Thank you!" to everyone who has encouraged us along the way. To those of you who worked with Phaser during its various incarnations. The number of games being released that were made with Phaser is staggering and we really love to see how you use it!  It's your kind words and enthusiasm that has keeps us going.
Phaser is everything we ever wanted from an HTML5 game framework. It powers all of our client work in build today and remains our single most important product, and we've still only just scratched the surface of what we have planned for it.
Getting Started Guides
We have a new Getting Started Guide which covers all you need to begin developing games with Phaser. From setting up a web server to picking an IDE. If you're new to HTML5 game development, or are coming from another language like AS3, then we recommend starting there.
There is a comprehensive How to Learn Phaser guide on the GameDevTuts+ site which is a great place to learn where to find tutorials, examples and support.
There is also an un-official Getting Started Guide.
Change Log
Version 1.1.4 - "Kandor" - February 5th 2014
Significant API changes:
- Loader.tileset has been removed as it's no longer required, this was as part of the Tilemap system overhaul.
- TilemapLayers are now created via the Tilemap object itself: map.createLayer(x, y, width, height, tileset, layer, group) and no longer via the GameObjectFactory.
- Tilemap.createFromObjects can now turn a bunch of Tiled objects into Sprites in one single call, and copies across all properties as well.
- Tween.onStartCallback and onCompleteCallback have been removed to avoid confusion. You should use the onStart, onLoop and onComplete events instead.
- Button.forceOut default value has changed from true to false, so Buttons will revert to an Up state (if set) when pressed and released.
- The way the collision process callback works has changed significantly and now works as originally intended.
- The World level quadtree is no longer created, they are now built and ripped down each time you collide a Group, this helps collision accuracy.
- A SAT system has been integrated for Body collision and separation.
- Bodies are no longer added to a world quadtree, so have had all of their quadtree properties removed such as skipQuadtree, quadTreeIndex, etc.
- Body.drag has been removed. Please use the new Body.linearDamping value instead (which is a number value, not a Point object)
- Body.embedded and Body.wasTouching have been removed as they are no longer required.
- Body.customSeparateX/Y have been removed as you should now use Body.customSeparateCallback.
- Body.maxVelocity defaults have been removed from 10,000 to 2000.
- Body.customSeparateCallback allows you to set your own callback when two Bodies need to separate rather than using the built-in method.
- Body.collideCallback allows you to set a callback that is fired whenever the Body is hit on any of its active faces.
- Body.allowCollision has been renamed to Body.checkCollision.
- Body.rebound is a boolean that controls if a body will exchange velocity on collision. Set to false to allow it to be 'pushed' (see new examples).
- Removed Body.deltaAbsX and deltaAbsY as they are no longer used internally.
- Body.screenX and screenY moved to getters, no longer calculated every frame.
- ArcadePhysics now has setBounds and setBoundsToWorld, and you can specify which walls are created or not (left, right, up, down)
- Removed: Debug.renderSpriteTouching, Debug.renderLocalTransformInfo, Debug.renderWorldTransformInfo, Debug.renderSpriteCollision and Debug.dumpLinkedList.
- Body.setSize has been removed. Please use Body.setCircle, setRectangle or setPolygon instead.
New features:
- Phaser.Timer is now feature complete and fully documented. You can create Phaser.TimerEvents on a Timer and lots of new examples have been provided.
- Gamepad API support has been added with lots of new examples (thanks Karl Macklin)
- Phaser.Game constructor can now be passed a single object containing all of your game settings + Stage settings. Useful for advanced configurations.
- The width/height given to Phaser.Game can now be percentages, i.e. "100%" will set the width to the maximum window innerWidth.
- Added a stage.fullScreenScaleMode property to determine scaling when fullscreen (thanks oysterCrusher)
- Added support for margin and spacing around a frame in Loader.spritesheet.
- Added Device.vibration to check if the Vibration API is available or not.
- Added Device.trident and Device.tridentVersion for testing IE11.
- Added Device.silk for detecting a Kindle Fire and updated desktop OS check to exclude Kindles (thanks LuckieLordie)
- TilemapLayers now have debug and debugAlpha values, this turns on the drawing of the collision edges (very handy for debugging, as the name implies!)
- Tweens have a new event: onLoop.
- You can now load any binary file via the Loader: game.load.binary(key, url, callback) - the optional callback allows for post-load processing before entering the Cache.
- Group.set will let you deep set a new propery on a single child of the Group.
- Stage.display property added. A direct reference to the root Pixi Stage object (very useful for RenderTexture manipulation)
- Added Ejecta detection to Device (thanks endel)
- Tweens can now work with relative + and - values. You can do:
tween(sprite).to( { x: '+400' })
and it will add 400 to the current sprite.x value. - Buttons now properly use their upFrame if set.
- InputHandler now has snapOffsetX and snapOffsetY properties so your snap grid doesn't have to be 0,0 aligned (thanks srmeier)
- Loader.progressFloat contains the actual non-rounded progress value, where-as Loader.progress contains a rounded value. Use progressFloat if you've > 100 files to load.
- Groups can now be added to other Groups as children via group.add() and group.addAt()
- Groups now have an 'alive' property, which can be useful when iterating through child groups with functions like forEachAlive.
- Added a new Project Template "Full Screen Mobile" which you can find in the resources folder. Contains html / css / layout needed for a deployed Phaser game.
- Body.speed - the current speed of the body.
- Body.angle - the current angle the Body is facing based on its velocity. This is not the same as the Sprite angle that may own the body.
- Body.linearDamping - This now replaces Body.drag and provides for a much smoother damping (friction) experience.
- Body.minBounceVelocity - If a Body has bounce set, this threshold controls if it should rebound or not. Use it to stop 'jittering' on bounds/tiles with super-low velocities.
- QuadTree.populate - you can pass it a Group and it'll automatically insert all of the children ready for inspection.
- Input.setMoveCallback allows you to set a callback that will be fired each time the activePointer receives a DOM move event.
- Math.distancePow(x1,y1,x2,y2,power) returns the distance between two coordinates at the given power.
- Physics.collide now supports the 2nd parameter as an array, for when you want to collide an object against a number of sprites that aren't all in the same Group.
- Physics.overlap now supports the 2nd parameter as an array, for when you want to overlap test an object against a number of sprites that aren't all in the same Group.
- Math.reverseAngle - reverses an angle (in radians).
- Math.normalizeAngle - normalises an angle, now in radians only.
- Math.normalizeLatitude - Normalizes a latitude to the [-90,90] range.
- Math.normalizeLongitude - Normalizes a longitude to the [-180,180] range.
- Phaser.Line added to the geometry classes, with full point on line/segment and intersection tests (see new examples)
- Phaser.CANVAS_PX_ROUND is a boolean. If 'true' the Canvas renderer will Math.floor() all coordinates before drawImage, stopping pixel interpolation. Defaults to false.
- Phaser.CANVAS_CLEAR_RECT is a boolean. If 'true' (the default) it will context.clearRect() every frame. If false this is skipped (useful if you know you don't need it)
- Collision now works between Sprites positioned via sprite.x/y, sprite.body.x/y or sprite.body.velocity.
- If you are tweening a sprite and still want physics collision, set
sprite.body.moves = false
otherwise it will fight against the tween motion. - Game.enableStep will enable core game loop stepping. When enabled you must call game.step() directly (perhaps via a DOM button?), very useful for debugging!
- Game.disableStep turns core update loop stepping off.
- Debug.renderPhysicsBody(body, color) is extremely useful for debugging the new physics bodies. Will draw the outline + points in the color given.
- Debug.renderBodyInfo(sprite, x, y, color) will display lots of Sprite body data.
- Sprite.events.onBeginContact will be fired when a Body makes contact with another Body. Once contact is over an onEndContact event will be dispatched.
New Examples:
- Physics - Bounce by Patrick OReilly.
- Physics - Bounce with gravity by Patrick OReilly.
- Physics - Bounce accelerator (use the keyboard) by Patrick OReilly.
- Physics - Bounce knock (use the keyboard) by Patrick OReilly.
- Physics - Snake (use the keyboard to control the snake like creature) by Patrick OReilly and Richard Davey.
- Physics - Launcher - Angry Birds style ball launcher demo by Patrick OReilly.
- Physics - Launcher Follow - throw the sprite anywhere in the world by Patrick OReilly.
- Physics - Launcher Follow World - an advanced version of the Launcher Follow example by Patrick OReilly.
- Input - Touch Joystick example showing how to use the clay.io virtual game controller (thanks gabehollombe)
- Games - Matching Pairs by Patrick OReilly.
- Games - Simon Says by Patrick OReilly.
- Games - Wabbits by Patrick OReilly.
- Tweens - Example showing how to use the tween events, onStart, onLoop and onComplete.
- Display - Pixi Render Texture. A Phaser conversion of the Pixi.js Render Texture example.
- Input - 5 new examples showing how to use the Gamepad API (thanks Karl Macklin)
- Animation - Group Creation, showing how to create animations across all Group children in one call.
- Particles - Rain by Jens Anders Bakke.
- Particles - Snow by Jens Anders Bakke.
- Groups - Nested Groups - showing how to embed one Group into another Group.
- Time - Lots of new examples showing how to use the updated Phaser.Timer class.
Updates:
- Updated to latest Pixi.js dev branch build (pre 1.4 release)
- When a Sprite is destroyed any active filters are removed at the same time.
- Updated Pixi.js so that removing filters now works correctly without breaking the display list.
- Phaser.Canvas.create updated so it can be given an ID as the 3rd parameter (can also be set via new Game configuration object).
- Updated display/fullscreen example to reflect new full screen change.
- Loads of updates to the TypeScript definitions files - games fully compile now and lots of missing classes added :) (thanks Niondir)
- Removed 'null parent' check from Group constructor. Will parent to game.world only if parent value is undefined.
- The tutorials have now been translated into Spanish - thanks feiss :)
- separateY updated to re-implement the 'riding platforms' special condition (thanks cocoademon)
- SoundManager.onSoundDecode now dispatches the key followed by the sound object, also now dispatched by the Cache when doing an auto-decode on load.
- Switch method of using trimmed sprites to support scaling and rotation (thanks cocoademon)
- Most of the GameObjectFactory functions now have a group parameter, so you can do: game.add.sprite(x, y, frame, frameName, group) rather than defaulting to the World group.
- Group.countLiving and countDead used to return -1 if the Group was empty, but now return 0.
- Text can now be fixedToCamera, updated world/fixed to camera example to show this.
- ArcadePhysics.overlap and collide now recognise TileSprites in the collision checks.
- Lots of documentation fixes in the Tween class.
- Tweens fire an onLoop event if they are set to repeat. onComplete is now only fired for the final repeat (or never if the repeat is infinite)
- Pointer used to un-pause a paused game every time it was clicked/touched (this avoided some rogue browser plugins). Now only happens if Stage.disableVisibilityChange is true.
- Input doesn't set the cursor to default if it's already set to none.
- You can now collide a group against itself. This will check all children against each other, but not themselves (thanks cocoademon)
- RenderTexture.render / renderXY has a new parameter: renderHidden, a boolean which will allow you to render Sprites even if their visible is set to false.
- Added in prototype.constructor definitions to every class (thanks darkoverlordofdata)
- Group.destroy has a new parameter: destroyChildren (boolean) which will optionally call the destroy method of all Group children.
- Button.clearFrames method has been added.
- Device.quirksMode is a boolean that informs you if the page is in strict (false) or quirks (true) mode.
- Canvas.getOffset now runs a strict/quirks check and uses document.documentElement when calculating scrollTop and scrollLeft to avoid Chrome console warnings.
- The Time class now has its own Phaser.Timer which you can access through game.time.events. See the new Timer examples to show how to use them.
- Added StateManager.getCurrentState to return the currently running State object (thanks Niondir)
- Removed the console.log redirect from Utils as it was messing with Firefox.
- Body.acceleration is now much smoother and less eratic at high speeds.
- Removed ArcadePhysics binding to the QuadTree, so it can now be used independantly of the physics system.
- Removed ArcadePhysics.preUpdate and postUpdate as neither are needed any more.
- Body.bottom and Body.right are no longer rounded, so will give accurate sub-pixel values.
- Fixed lots of documentation in the Emitter class.
- The delta timer value used for physics calculations has had its cap limit modified from 1.0 to 0.05 in line with the core updates.
- Phaser.Math.min enhanced so you can now pass in either an array of numbers or lots of numbers as parameters to get the lowest.
- Phaser.Math.max added as the opposite of Math.min.
- Phaser.Math.minProperty and maxProperty added. Like Math.min/max but can be given a property an an array or list of objects to inspect.
- Added 'full' paramter to Body.reset, allowing you to control if motion or all data is reset or not.
- Exposed Group.pivot and Sprite.pivot to allow you to directly set the pivot points for rotation.
- Swapped to using the native and faster Array.isArray check.
- Added callback context parameter to Tween.onUpdateCallback(callback, context) to avoid having to bind or create anonymous functions.
- Updated TweenManager.removeAll so it flags all tweens as pendingDelete rather than nuking the array, to avoid tween callback array size errors (thanks DarkDev)
Bug Fixes:
- Cache.getImageKeys returned __missing in the array, now excluded.
- Fixed Group.scale so you can now scale a Group directly.
- Removed World.scale as it was preventing Group.scale from working - you can still scale the world, but you'll need to factor in Input changes yourself.
- Moved 'dirty' flag for Tilemap to a per-layer flag. Fixes #242
- Group.length now returns the number of children in the Group regardless of their exists/alive state, or 0 if the Group has no children.
- Switch Camera.setBoundsToWorld to match world.bounds instead of world (thanks cocoademon)
- Fixed an issue where passing null as the Group parent wouldn't set it to game.world as it should have (thanks tito100)
- Fixed Pixi bug (#425) incorrect width property for multi-line BitmapText (thanks jcd-as)
- Tween.onStart is now called when the tween starts AFTER the delay value, if given (thanks stevenbouma)
- Sprites that are fixedToCamera can now be input dragged regardless of world position (thanks RafaelOliveira)
- RenderTexture now displays correctly in Canvas games.
- Canvas.addToDOM is now more robust when applying the overflowHidden style.
- Fixed Pixi.StripShader which should stop the weird TileSprite GPU issues some were reporting (thanks GoodboyDigital)
- Patched desyrel.xml so it doesn't contain any zero width/height characters, as they broke Firefox 25.
- Cache.addSound now implements a locked attribute (thanks haden)
- Sound now checks for CocoonJS during playback to avoid readyState clash (thanks haden)
- Buttons now clear previously set frames correctly if you call setFrames.
- Sounds will now loop correctly if they are paused and resumed (thanks haden)
- InputHandler.checkBoundsRect and checkBoundsSprite now take into account if the Sprite is fixedToCamera or not.
- Removed the frame property from TileSprites as it cannot use them, it tiles the whole image only, not just a section of it.
- Fixed WebGLRenderer updateGraphics bug (thanks theadam)
- Removed duplicate Timer.create line (thanks hstolte)
- Fixed issue with the camera being slightly out of sync with 'fixedToCamera' sprites.
- 1px camera jitter issue fixed where map is same size, or smaller than the game size.
You can view the Change Log for all previous versions at https://github.com/photonstorm/phaser/changelog.md
How to Build
We provide a fully compiled version of Phaser in the build
directory, in both plain and minified formats.
We also provide a Grunt script that will build Phaser from source along with all the examples.
Run grunt
in the phaser folder for a list of command-line options.
Koding
You can ![clone the Phaser repo in Koding]koding and then start editing and previewing code right away using their web based VM development system.
Bower
If you use bowser you can install phaser with:
bower install phaser
Nice and easy :)
CDNJS
Thanks to a community member Phaser is now available on CDNJS. You can include the following in your html:
http://cdnjs.cloudflare.com/ajax/libs/phaser/1.1.3/phaser.min.js
Or if you prefer you can leave the protocol off, so it works via http and https:
//cdnjs.cloudflare.com/ajax/libs/phaser/1.1.3/phaser.min.js
Requirements
Games created with Phaser require a modern web browser that supports the canvas tag. This includes Internet Explorer 9+, Firefox, Chrome, Safari and Opera. It also works on mobile web browsers including stock Android 2.x browser and above and iOS5 Mobile Safari and above.
For developing with Phaser you can use either a plain-vanilla JavaScript approach or TypeScript using the provided TypeScript definitions file. We made no assumptions about how you like to code your games, and were careful not to impose any form of class/inheritance/structure upon you.
Phaser is 321 KB minified and 72 KB gzipped.
Learn By Example
Phaser comes with an ever growing suite of Examples. Personally I feel that we learn better by looking at small refined code examples, so we created over 200 of them and create new ones to test every new feature added. Inside the examples
folder you'll find the current set. If you write a particularly good example then please send it to us.
The examples need to be run through a local web server (in order to avoid file access permission errors from your browser). You can use your own web server, or start the included web server using grunt.
Using a locally installed web server browse to the examples folder:
examples/index.html
Alternatively in order to start the included web server, after you've cloned the repo, run npm install
to install all dependencies, then grunt connect
to start a local server. After running this command you should be able to access your local webserver at http://<IP_ADDRESS>:8000
. Then browse to the examples folder: http://<IP_ADDRESS>:8000/examples/index.html
There is a new 'Side View' example viewer as well. This loads all the examples into a left-hand frame for faster navigation.
You can also browse all Phaser Examples online.
Features
WebGL & Canvas
Phaser uses both a Canvas and WebGL renderer internally and can automatically swap between them based on browser support. This allows for lightning fast rendering across Desktop and Mobile. When running under WebGL Phaser now supports shaders, allowing for some incredible in-game effects. Phaser uses and contributes towards the excellent Pixi.js library for rendering.
Preloader
We've made the loading of assets as simple as one line of code. Images, Sounds, Sprite Sheets, Tilemaps, JSON data, XML and JavaScrtip files - all parsed and handled automatically, ready for use in game and stored in a global Cache for Sprites to share.
Physics
Phaser ships with our Arcade Physics system. A SAT based collision and physics library perfect for low-powered devices and fast collision response. Control velocity, acceleration, bounce, damping and full collision and separation control. As of version 1.1.4 we now support rectangles, circles and polygon collision with full rotation.
Sprites
Sprites are the life-blood of your game. Position them, tween them, rotate them, scale them, animate them, collide them, paint them onto custom textures and so much more! Sprites also have full Input support: click them, touch them, drag them around, snap them - even pixel perfect click detection if needed.
Groups
Group bundles of Sprites together for easy pooling and recycling, avoiding constant object creation. Groups can also be collided: for example a "Bullets" group checking for collision against the "Aliens" group, with a custom collision callback to handle the outcome.
Animation
Phaser supports classic Sprite Sheets with a fixed frame size, Texture Packer and Flash CS6/CC JSON files (both Hash and Array formats) and Starling XML files. All of these can be used to easily create animation for Sprites.
Particles
An Arcade Particle system is built-in, which allows you to create fun particle effects easily. Create explosions or constant streams for effects like rain or fire. Or attach the Emitter to a Sprite for a jet trail.
Camera
Phaser has a built-in Game World. Objects can be placed anywhere within the world and you've got access to a powerful Camera to look into that world. Pan around and follow Sprites with ease.
Input
Talk to a Phaser.Pointer and it doesn't matter if the input came from a touch-screen or mouse, it can even change mid-game without dropping a beat. Multi-touch, Mouse, Keyboard and lots of useful functions allow you to code custom gesture recognition.
Sound
Phaser supports both Web Audio and legacy HTML Audio. It automatically handles mobile device locking, easy Audio Sprite creation, looping, streaming and volume. We know how much of a pain dealing with audio on mobile is, so we did our best to resolve that!
Tilemaps
Phaser can load, render and collide with a tilemap with just a couple of lines of code. We support CSV and Tiled map data formats with multiple tile layers. There are lots of powerful tile manipulation functions: swap tiles, replace them, delete them, add them and update the map in realtime.
Device Scaling
Phaser has a built-in Scale Manager which allows you to scale your game to fit any size screen. Control aspect ratios, minimum and maximum scales and full-screen support.
Plugin system
We are trying hard to keep the core of Phaser limited to only essential classes, so we built a smart Plugin system to handle everything else. Create your own plugins easily and share them with the community.
Mobile Browser
Phaser was built specifically for Mobile web browsers. Of course it works blazingly fast on Desktop too, but unlike lots of frameworks mobile was our main focus. If it doesn't perform well on mobile then we don't add it into the Core.
Developer Support
We use Phaser every day on our many client projects. As a result it's constantly evolving and improving and we jump on bugs and pull requests quickly. This is a living, breathing framework maintained by a commercial company with custom feature development and support packages available. We live and breathe HTML5 games.
Battle Tested
Although Phaser 1.0 is a brand new release it is born from years of experience building some of the biggest mobile HTML5 games out there. We're not saying it is 100% bug free, but we use it for our client work every day, so issues get resolved <em>fast</em> and we stay on-top of the changing browser landscape.
Road Map
Here is what's on our road map for the coming months:
Version 1.1.5 ("Saldaea")
- A fast turn-around point release that will focus on addressing any bugs that occured as a result of the large changes that took place in 1.1.4.
Version 1.2 ("Shienar")
- Update to Pixi 1.4 - this newly released build has lots of internal changes and new features we want to take advantage of.
Version 1.3 ("Tarabon")
- Enhance the State Management, so you can perform non-destructive State swaps and persistence.
- Dedicated CocoonJS packaging features (screencanvas, etc)
- A more advanced Particle system, one that can render to a single canvas (rather than spawn hundreds of Sprites), more advanced effects, etc.
- Ability to control DOM elements from the core game and layer them into the game.
- Touch Gestures.
- Support for parallel asset loading.
- Fixed width bitmap font support, plus enhanced Bitmap font rendering.
Version 2.0 ("Aes Sedai")
- Integrate p2.js physics system completely.
- Comprehensive testing across Firefox OS devices, CocoonJS and Ejecta.
- Integration with third party services like Google Play Game Services and Amazon JS SDK.
- Flash CC HTML5 export integration.
- Massively enhance the audio side of Phaser. Although it does what it does well, it could do with taking more advantage of Web Audio - echo effects, positional sound, etc.
Beyond version 2.0
- Test out packaging with Node-webkit.
- Game parameters stored in Google Docs.
- Look at HiDPI Canvas settings.
- Multiple Camera support.
Contributing
We now have a full Contributors Guide which goes into the process in more detail, but here are the headlines:
If you find a bug then please report it on GitHub Issues or our Support Forum.
If you have a feature request, or have written a game or demo that shows Phaser in use, then please get in touch. We'd love to hear from you! Either post to our forum or email<EMAIL_ADDRESS>If you issue a Pull Request for Phaser, please only do so againt the
dev
branch and not against themaster
branch.Before submitting a Pull Request please run your code through JSHint to check for stylistic or formatting errors. To use JSHint, first install it by running
npm install jshint
, then test your code by runningjshint src
. This isn't a strict requirement and we are happy to receive Pull Requests that haven't been JSHinted, so don't let it put you off contributing, but do know that we'll reformat your source before going live with it.
Bugs?
Please add them to the Issue Tracker with as much info as possible, especially source code demonstrating the issue.
"Being negative is not how we make progress" - Larry Page, Google
License
Phaser is released under the MIT License.


CAUGHT LIVE
Yungblud took Glasgow’s SWG3 by storm as he gave an electric performance
by Jessie WilsonYUNGBLUD took Glasgow’s SWG3 by storm as he gave an electric performance.
The 22-year-old, whose real name in Dominic Harrison, bounced relentlessly across the stage as the vibrant crowd screamed every word to hit tune 21st Century Liability.
He only stopped briefly to pick up a bra launched towards him by a fan.

"Or have you already lost it?”

“No one can f***ing touch us.
He followed on from support band Saint Phnx, comprised of brothers Stevie and Alan Jukes from Wishaw.
They soared through their set while the crowd echoed the band’s infectious energy in true Glasgow style.
SET LIST
21st Century Liability
Parents
I Love You, Will You Marry Me
King Charles
Anarchist
Polygraph Eyes
Ice Cream Man
Original Me
Loner
Siren Interlude
Kill Somebody
Live Interlude
I Think I'm OKAY(Machine Gun Kelly cover)
Casual Sabotage
Waiting on the Weekend
California
Braindead!
Hope for the Underrated Youth
Machine Gun (F**k the NRA)
Yungblud’s latest EP, the Underrated Youth, came out in October this year.
He is a figurehead for his own pop-punk protest movement.
And as the adoring crowd screamed Kill Somebody along with him as he took centre stage in a mosh pit, there was a tangible feeling of love, defiant rage, and above all, hope.
He reappeared on the stage in a black mini skirt and an acoustic guitar before belting out Casual Sabotage - an anthem for the “freaks” and the “rejects”.
And he finished his encore with every hand in the air as Glasgow sang: “There’s hope for the underrated youth”.


{%extends "layout.html"%} {%block content%}
{{ info | safe}}
Now please select time span for which you would like to generate stock price graph:
Please note that maximum start date can be set to 3 days before today.
Data goes back to 2005.
Chose maximum time span of 1 year.


Worked on Python, Django, JavaScript and PHP projects.
Collaborated effectively with members of software development
team to fix the bugs or add some new features in existing software
as well as contributed in the development of the new ERP for the
organization and wrote the documentation.
Extracurricular Activities
Modular Program in Cloud Computing
Learnt about basics of cloud computing, github, docker, etc
Some Projects on Azure Cloud Platform
Learnt Azure Cloud essentials, creating and managing cloud resources, cloud infrastructure, Cloud Architecture: Design, Implement, and Manage.


Sofie Löhr
Visualization
Information
Visualizations
For more information and explanation about the visualizations, go to the Information page!
Bubble chart
Line chart
Pie chart
Incoming
Outgoing


{{/* Use this to organize the way text wraps around an iframe or figure: {{< clear >}} {{< inlineScene entry="first-steps/toy-train-rotated.js" class="small right" >}} Use sparingly - it has to be carefully checked and tuned for mobile and usually required paragraphs to be split up to work nicely. */}}


All Classes
Bullet
Camera
Enemy
Entity
FloorTile
Game
GameInput
GameScreen
LifePack
Player
Spritesheet
Tile
WallTile
Wepon
World


JQuery Workshop
hide a paragraph text by clicking on text and click me to change bg
click me to hide
"double click me"
to change my font and color
hover me
I'm On method
toggle text
Toggle
click me to FADE
I'm animated text
Stop sliding
click to slide down
Hi there


package client2server
Type Members
- class AnonymousAudienceChatFromClientAE extends AnonymousAudienceChatAnalysisEngine
- class BoardAE extends BoardAnalysisEngine
- class BuildVillageAE extends BuildVillageAnalysisEngine
- class ChatFromClientAE extends ChatAnalysisEngine
- class ErrorFromClientAE extends ErrorAnalysisEngine
- class LeaveWaitingPageAE extends LeaveWaitingPageAnalysisEngine
- class OnymousAudienceBoardAE extends OnymousAudienceBoardAnalysisEngine
- class OnymousAudienceChatFromClientAE extends OnymousAudienceChatAnalysisEngine
- class OnymousAudienceScrollAE extends OnymousAudienceScrollAnalysisEngine
- class ReadyAE extends ReadyAnalysisEngine
- class ReceivedChatMessageAE extends ReceivedChatMessageAnalysisEngine
- class ReceivedFlavorTextMessageAE extends ReceivedFlavorTextMessageAnalysisEngine
- class ReceivedSystemMessageAE extends ReceivedSystemMessageAnalysisEngine
- class ScrollAE extends ScrollAnalysisEngine
- class StarAE extends StarAnalysisEngine
- class VoteAE extends VoteAnalysisEngine


According to Vincent’s original blog post, he’s listed all of the individual Git commands that you need to use to create all of the different branches in the GitFlow model. They’re all standard Git commands … and if you’re also still getting your head around Git (and still learning why it is different to centralised source control systems like Subversion, or replicated source control systems like Mercurial), it adds to what is already quite a steep learning curve.
Vincent created an extension for Git, called GitFlow, which turns most of the steps you need to do into one-line commands. At DataSift, we used it for six months, and we liked it - but we wanted it to do even more. We also wanted it to work better with GitHub, so to reduce confusion with the original GitFlow tools, we’ve decided to maintain our own fork of the GitFlow tools called HubFlow.
HubFlow is:
The main differences between the original GitFlow tools and HubFlow are:
Installing the HubFlow tools for the first time is very easy:
If you want to upgrade to the latest version of HubFlow, simply run:
To see all of the commands that HubFlow provides, simply run:


class Bauxite::Context
The Main test context. This class includes state and helper functions used by clients execute tests and by actions and selectors to interact with the test engine (i.e. Selenium WebDriver).
Context variables¶ ↑
Context variables are a key/value pairs scoped to the a test context.
Variables can be set using different actions. For example:
-
Bauxite::Action#set sets a variable to a literal string.
-
Bauxite::Action#store sets a variable to the value of an element in the page.
-
Bauxite::Action#exec sets a variable to the output of an external command (i.e. stdout).
-
Bauxite::Action#js sets a variable to the result of Javascript command.
-
Bauxite::Action#replace sets a variable to the result of doing a find-and-replace operation on a literal.
Variables can be expanded in every Action argument (e.g. selectors, texts, expressions, etc.). To obtain the value of a variable through variable expansion the following syntax must be used:
${var_name}
For example:
set field "greeting" set name "John" write "${field}_textbox" "Hi, my name is ${name}!" click "${field}_button"
Variable scope¶ ↑
When the main test starts (via the start method), the test is bound to the global scope. The variables defined in the global scope are available to every test Action.
The global scope can have nested variable scopes created by special
actions. The variables defined in a scope A
are only available
to that scope and scopes nested within A
.
Every time an Action loads a file, a new nested scope is created. File-loading actions include:
A nested scope can bubble variables to its parent scope with the special action:
Built-in variable¶ ↑
Bauxite has a series of built-in variables that provide information of the current test context and allow dynamic constomizations of the test behavior.
The built-in variables are:
__FILE__
-
The file where the current action is defined.
__DIR__
-
The directory where
__FILE__
is. __SELECTOR__
-
The default selector used when the selector specified does not contain an
=
character. __DEBUG__
-
Set to true if the current action is being executed by the debug console.
__RETURN__
-
Used internally by Bauxite::Action#return_action to indicate which variables should be returned to the parent scope.
In general, variables surrounded by double underscores and variables whose names are only numbers are reserved for Bauxite and should not be used as part of a functional test. The obvious exception is when trying to change the test behavior by changing the built-in variables.
Attributes
Logger instance.
Test options.
Test containers.
Context variables.
Public Class Methods
Constructs a new test context instance.
options
is a hash with the following values:
- :driver
-
selenium driver symbol (defaults to
:firefox
) - :timeout
-
selector timeout in seconds (defaults to
10s
) - :logger
-
logger implementation name without the 'Logger' suffix (defaults to 'null' for Loggers::NullLogger).
- :verbose
-
if
true
, show verbose error information (e.g. backtraces) if an error occurs (defaults tofalse
) - :debug
-
if
true
, break into the debug console if an error occurs (defaults tofalse
) - :wait
-
if
true
, call ::wait before stopping the test engine with stop (defaults tofalse
) - :extensions
-
an array of directories that contain extensions to be loaded
# File lib/bauxite/core/context.rb, line 138 def initialize(options) @options = options @driver_name = (options[:driver] || :firefox).to_sym @variables = { '__TIMEOUT__' => (options[:timeout] || 10).to_i, '__DEBUG__' => false, '__SELECTOR__' => options[:selector] || 'sid', '__OUTPUT__' => options[:output], '__DIR__' => File.absolute_path(Dir.pwd) } @aliases = {} @tests = [] client = Selenium::WebDriver::Remote::Http::Default.new client.timeout = (@options[:open_timeout] || 60).to_i @options[:driver_opt] = {} unless @options[:driver_opt] @options[:driver_opt][:http_client] = client _load_extensions(options[:extensions] || []) @logger = Context::load_logger(options[:logger], options[:logger_opt]) @parser = Parser.new(self) end
Public Instance Methods
Breaks into the debug console.
For example:
ctx.debug # => this breaks into the debug console
# File lib/bauxite/core/context.rb, line 269 def debug exec_parsed_action('debug', [], false) end
Test engine driver instance (Selenium WebDriver).
# File lib/bauxite/core/context.rb, line 259 def driver _load_driver unless @driver @driver end
Finds an element by selector
.
The element found is yielded to the given block
(if any) and
returned.
Note that the recommeneded way to call this method is by passing a
block
. This is because the method ensures that the element
context is maintained for the duration of the block
but it
makes no guarantees after the block
completes (the same
applies if no block
was given).
For example:
ctx.find('css=.my_button') { |element| element.click } ctx.find('css=.my_button').click
For example (where using a block
is mandatory):
ctx.find('frame=|myframe|css=.my_button') { |element| element.click } # => .my_button clicked ctx.find('frame=|myframe|css=.my_button').click # => error, cannot click .my_button (no longer in myframe scope)
# File lib/bauxite/core/context.rb, line 252 def find(selector, &block) # yields: element with_timeout Selenium::WebDriver::Error::NoSuchElementError do Selector.new(self, @variables['__SELECTOR__']).find(selector, &block) end end
Returns the value of the specified element
.
This method takes into account the type of element and selectively returns
the inner text or the value of the value
attribute.
For example:
# assuming <input type='text' value='Hello' /> # World! ctx.get_value(ctx.find('css=input[type=text]')) # => returns 'Hello' ctx.get_value(ctx.find('label')) # => returns 'World!'
# File lib/bauxite/core/context.rb, line 288 def get_value(element) if ['input','select','textarea'].include? element.tag_name.downcase element.attribute('value') else element.text end end
Stops the test engine and starts a new engine with the same provider.
For example:
ctx.reset_driver => closes the browser and opens a new one
# File lib/bauxite/core/context.rb, line 200 def reset_driver @driver.quit if @driver @driver = nil end
Starts the test engine and executes the actions specified. If no action was specified, returns without stopping the test engine (see stop).
For example:
lines = [ 'open "http://www.ruby-lang.org"', 'write "name=q" "ljust"', 'click "name=sa"', 'break' ] ctx.start(lines) # => navigates to www.ruby-lang.org, types ljust in the search box # and clicks the "Search" button.
# File lib/bauxite/core/context.rb, line 177 def start(actions = []) return unless actions.size > 0 begin actions.each do |action| begin break if exec_action(action) == :break rescue StandardError => e print_error(e) raise unless @options[:debug] debug end end ensure stop end end
Stops the test engine.
Calling this method at the end of the test is mandatory if start was called without
actions
.
Note that the recommeneded way of executing tests is by passing a list of
actions
to start
instead of using the start / stop pattern.
For example:
ctx.start(:firefox) # => opens firefox # test stuff goes here ctx.stop # => closes firefox
# File lib/bauxite/core/context.rb, line 220 def stop Context::wait if @options[:wait] begin @logger.finalize(self) rescue StandardError => e print_error(e) raise ensure @driver.quit if @driver end end
Advanced Helpers
↑ topPublic Class Methods
Constructs a Logger instance using name
as a hint for the
logger type.
# File lib/bauxite/core/context.rb, line 432 def self.load_logger(loggers, options) if loggers.is_a? Array return Loggers::CompositeLogger.new(options, loggers) end name = loggers log_name = (name || 'null').downcase class_name = "#{log_name.capitalize}Logger" unless Loggers.const_defined? class_name.to_sym raise NameError, "Invalid logger '#{log_name}'" end Loggers.const_get(class_name).new(options) end
Default action parsing strategy.
# File lib/bauxite/core/context.rb, line 460 def self.parse_action_default(text, file = '<unknown>', line = 0) data = text.split(' ', 2) begin args_text = data[1] ? data[1].strip : '' args = [] unless args_text == '' # col_sep must be a regex because String.split has a # special case for a single space char (' ') that produced # unexpected results (i.e. if line is '"a b"' the # resulting array contains ["a b"]). # # ...but... # # CSV expects col_sep to be a string so we need to work # some dark magic here. Basically we proxy the StringIO # received by CSV to returns strings for which the split # method does not fold the whitespaces. # args = CSV.new(StringIOProxy.new(args_text), { :col_sep => ' ' }) .shift .select { |a| a != nil } || [] end { :action => data[0].strip.downcase, :args => args } rescue StandardError => e raise "#{file} (line #{line+1}): #{e.message}" end end
Prompts the user to press ENTER before resuming execution.
For example:
Context::wait # => echoes "Press ENTER to continue" and waits for user input
# File lib/bauxite/core/context.rb, line 425 def self.wait Readline.readline("Press ENTER to continue\n") end
Public Instance Methods
Adds an alias named name
to the specified action
with the arguments specified in args
.
# File lib/bauxite/core/context.rb, line 454 def add_alias(name, action, args) @aliases[name] = { :action => action, :args => args } end
Executes the specified action string handling errors, logging and debug history.
If log
is true
, log the action execution (default
behavior).
For example:
ctx.exec_action 'open "http://www.ruby-lang.org"' # => navigates to www.ruby-lang.org
# File lib/bauxite/core/context.rb, line 309 def exec_action(text) data = Context::parse_action_default(text, '<unknown>', 0) exec_parsed_action(data[:action], data[:args], true, text) end
Executes the specified action object injecting built-in variables. Note
that the result returned by this method might be a lambda. If this is the
case, a further call
method must be issued.
This method if part of the action execution chain and is intended for advanced use (e.g. in complex actions). To execute an Action directly, the exec_action method is preferred.
For example:
action = ctx.get_action("echo", ['Hi!'], 'echo "Hi!"') ret = ctx.exec_action_object(action) ret.call if ret.respond_to? :call
# File lib/bauxite/core/context.rb, line 540 def exec_action_object(action) action.execute end
Executes the specified file
.
For example:
ctx.exec_file('file') # => executes every action defined in 'file'
# File lib/bauxite/core/context.rb, line 320 def exec_file(file) current_dir = @variables['__DIR__' ] current_file = @variables['__FILE__'] current_line = @variables['__LINE__'] @parser.parse(file) do |action, args, text, file, line| @variables['__DIR__'] = File.absolute_path(File.dirname(file)) @variables['__FILE__'] = file @variables['__LINE__'] = line break if exec_parsed_action(action, args, true, text) == :break end @variables['__DIR__' ] = current_dir @variables['__FILE__'] = current_file @variables['__LINE__'] = current_line end
Executes the specified action handling errors, logging and debug history.
If log
is true
, log the action execution (default
behavior).
This method if part of the action execution chain and is intended for advanced use (e.g. in complex actions). To execute an Action directly, the exec_action method is preferred.
For example:
ctx.exec_action 'open "http://www.ruby-lang.org"' # => navigates to www.ruby-lang.org
# File lib/bauxite/core/context.rb, line 350 def exec_parsed_action(action, args, log = true, text = nil) action = get_action(action, args, text) ret = nil if log @logger.log_cmd(action) do Readline::HISTORY << action.text ret = exec_action_object(action) end else ret = exec_action_object(action) end if ret.respond_to? :call # delayed actions (after log_cmd) ret.call else ret end rescue Selenium::WebDriver::Error::UnhandledAlertError raise Bauxite::Errors::AssertionError, "Unexpected modal present" end
Returns an executable Action object constructed from the specified arguments resolving action aliases.
This method if part of the action execution chain and is intended for advanced use (e.g. in complex actions). To execute an Action directly, the exec_action method is preferred.
# File lib/bauxite/core/context.rb, line 500 def get_action(action, args, text = nil) while (alias_action = @aliases[action]) action = alias_action[:action] args = alias_action[:args].map do |a| a.gsub(/\$\{(\d+)(\*q?)?\}/) do |match| # expand ${1} to args[0], ${2} to args[1], etc. # expand ${4*} to "#{args[4]} #{args[5]} ..." # expand ${4*q} to "\"#{args[4]}\" \"#{args[5]}\" ..." idx = $1.to_i-1 if $2 == nil args[idx] || '' else range = args[idx..-1] range = range.map { |arg| '"'+arg.gsub('"', '""')+'"' } if $2 == '*q' range.join(' ') end end end end text = ([action] + args.map { |a| '"'+a.gsub('"', '""')+'"' }).join(' ') unless text file = @variables['__FILE__'] line = @variables['__LINE__'] Action.new(self, action, args, text, file, line) end
Returns the output path for path
accounting for the
__OUTPUT__
variable.
For example:
# assuming --output /mnt/disk ctx.output_path '/tmp/myfile.txt' # => returns '/tmp/myfile.txt' ctx.output_path 'myfile.txt' # => returns '/mnt/disk/myfile.txt'
# File lib/bauxite/core/context.rb, line 585 def output_path(path) unless Pathname.new(path).absolute? output = @variables['__OUTPUT__'] if output Dir.mkdir output unless Dir.exists? output path = File.join(output, path) end end path end
Prints the specified error
using the Logger configured and
handling the verbose option.
For example:
begin # => some code here rescue StandardError => e @ctx.print_error e # => additional error handling code here end
# File lib/bauxite/core/context.rb, line 555 def print_error(e, capture = true) if @logger @logger.log "#{e.message}\n", :error else puts e.message end if @options[:verbose] p e puts e.backtrace end if capture and @options[:capture] with_vars(e.variables) do exec_parsed_action('capture', [] , false) e.variables['__CAPTURE__'] = @variables['__CAPTURE__'] end end end
Executes the given block using the specified driver timeout
.
Note that the driver timeout
is the time (in seconds) Selenium
will wait for a specific element to appear in the page (using any of the
available Selector strategies).
For example
ctx.with_driver_timeout 0.5 do ctx.find ('find_me_quickly') do |e| # do something with e end end
# File lib/bauxite/core/context.rb, line 410 def with_driver_timeout(timeout) current = @driver_timeout driver.manage.timeouts.implicit_wait = timeout yield ensure @driver_timeout = current driver.manage.timeouts.implicit_wait = current end
Executes the given block retrying for at most ${__TIMEOUT__}
seconds. Note that this method does not take into account the time it takes
to execute the block itself.
For example
ctx.with_timeout StandardError do ctx.find ('element_with_delay') do |e| # do something with e end end
# File lib/bauxite/core/context.rb, line 382 def with_timeout(*error_types) stime = Time.new timeout ||= stime + @variables['__TIMEOUT__'].to_i yield rescue *error_types => e t = Time.new rem = timeout - t raise if rem < 0 @logger.progress(rem.round) sleep(1.0/10.0) if (t - stime).to_i < 1 retry end
Metadata
↑ topPublic Class Methods
Returns an array with the names of the arguments of the specified action.
For example:
Context::action_args 'assert' # => [ "selector", "text" ]
# File lib/bauxite/core/context.rb, line 616 def self.action_args(action) action += '_action' unless _action_methods.include? action Action.public_instance_method(action).parameters.map { |att, name| name.to_s } end
Returns an array with the names of every action available.
For example:
Context::actions # => [ "assert", "break", ... ]
# File lib/bauxite/core/context.rb, line 606 def self.actions _action_methods.map { |m| m.sub(/_action$/, '') } end
Returns an array with the names of every logger available.
For example:
Context::loggers # => [ "null", "bash", ... ]
# File lib/bauxite/core/context.rb, line 645 def self.loggers Loggers.constants.map { |l| l.to_s.downcase.sub(/logger$/, '') } end
Returns the maximum size in characters of an action name.
This method is useful to pretty print lists of actions
For example:
# assuming actions = [ "echo", "assert", "tryload" ] Context::max_action_name_size # => 7
# File lib/bauxite/core/context.rb, line 669 def self.max_action_name_size actions.inject(0) { |s,a| a.size > s ? a.size : s } end
Returns an array with the names of every parser available.
For example:
Context::parsers # => [ "default", "html", ... ]
# File lib/bauxite/core/context.rb, line 655 def self.parsers (Parser.public_instance_methods(false) \ - ParserModule.public_instance_methods(false)) .map { |p| p.to_s } end
Returns an array with the names of every selector available.
If include_standard_selectors
is true
(default
behavior) both standard and custom selector are returned, otherwise only
custom selectors are returned.
For example:
Context::selectors # => [ "class", "id", ... ]
# File lib/bauxite/core/context.rb, line 631 def self.selectors(include_standard_selectors = true) ret = Selector.public_instance_methods(false).map { |a| a.to_s.sub(/_selector$/, '') } if include_standard_selectors ret += Selenium::WebDriver::SearchContext::FINDERS.map { |k,v| k.to_s } end ret end
Variable manipulation methods
↑ topPublic Instance Methods
Recursively replaces occurencies of variable expansions in s
with the corresponding variable value.
The variable expansion expression format is:
'${variable_name}'
For example:
ctx.variables = { 'a' => '1', 'b' => '2', 'c' => 'a' } ctx.expand '${a}' # => '1' ctx.expand '${b}' # => '2' ctx.expand '${c}' # => 'a' ctx.expand '${${c}}' # => '1'
# File lib/bauxite/core/context.rb, line 690 def expand(s) result = @variables.inject(s) do |s,kv| s = s.gsub(/\$\{#{kv[0]}\}/, kv[1].to_s) end result = expand(result) if result != s result end
Temporarily alter the value of context variables.
This method alters the value of the variables specified in the
vars
hash for the duration of the given block
.
When the block
completes, the original value of the context
variables is restored.
For example:
ctx.variables = { 'a' => '1', 'b' => '2', c => 'a' } ctx.with_vars({ 'a' => '10', d => '20' }) do p ctx.variables # => {"a"=>"10", "b"=>"2", "c"=>"a", "d"=>"20"} end p ctx.variables # => {"a"=>"1", "b"=>"2", "c"=>"a"}
# File lib/bauxite/core/context.rb, line 713 def with_vars(vars) current = @variables @variables = @variables.merge(vars) ret_vars = nil ret = yield returned = @variables['__RETURN__'] if returned == ['*'] ret_vars = @variables.clone ret_vars.delete '__RETURN__' elsif returned != nil ret_vars = @variables.select { |k,v| returned.include? k } end rescue StandardError => e e.instance_variable_set "@variables", @variables def e.variables @variables end raise ensure @variables = current @variables.merge!(ret_vars) if ret_vars ret end


|
QuantLib: a free/open-source library for quantitative finance
Fully annotated sources - version 1.30
|
Curve state for market-model simulations More...
#include <ql/models/marketmodels/curvestate.hpp>
Public Member Functions | |
| CurveState (const std::vector< Time > &rateTimes) | |
| virtual | ~CurveState ()=default |
Inspectors | |
| Size | numberOfRates_ |
| std::vector< Time > | rateTimes_ |
| std::vector< Time > | rateTaus_ |
| Size | numberOfRates () const |
| const std::vector< Time > & | rateTimes () const |
| const std::vector< Time > & | rateTaus () const |
| virtual Real | discountRatio (Size i, Size j) const =0 |
| virtual Rate | forwardRate (Size i) const =0 |
| virtual Rate | coterminalSwapAnnuity (Size numeraire, Size i) const =0 |
| virtual Rate | coterminalSwapRate (Size i) const =0 |
| virtual Rate | cmSwapAnnuity (Size numeraire, Size i, Size spanningForwards) const =0 |
| virtual Rate | cmSwapRate (Size i, Size spanningForwards) const =0 |
| virtual const std::vector< Rate > & | forwardRates () const =0 |
| virtual const std::vector< Rate > & | coterminalSwapRates () const =0 |
| virtual const std::vector< Rate > & | cmSwapRates (Size spanningForwards) const =0 |
| Rate | swapRate (Size begin, Size end) const |
| virtual std::unique_ptr< CurveState > | clone () const =0 |
Curve state for market-model simulations
This class stores the state of the yield curve associated to the fixed calendar times within the simulation. This is the workhorse discounting object associated to the rate times of the simulation. It's important to pass the rates via an object like this to the product rather than directly to make it easier to switch to other engines such as a coterminal swap rate engine. Many products will not need expired rates and others will only require the first rate.
Definition at line 41 of file curvestate.hpp.
| CurveState | ( | const std::vector< Time > & | rateTimes | ) |
|
virtualdefault |
| Size numberOfRates | ( | ) | const |
| const std::vector< Time > & rateTimes | ( | ) | const |
| const std::vector< Time > & rateTaus | ( | ) | const |
Implemented in CMSwapCurveState, CoterminalSwapCurveState, and LMMCurveState.
Implemented in CMSwapCurveState, CoterminalSwapCurveState, and LMMCurveState.
Implemented in CMSwapCurveState, CoterminalSwapCurveState, and LMMCurveState.
Implemented in CMSwapCurveState, CoterminalSwapCurveState, and LMMCurveState.
Implemented in CMSwapCurveState, CoterminalSwapCurveState, and LMMCurveState.
Implemented in CMSwapCurveState, CoterminalSwapCurveState, and LMMCurveState.
|
pure virtual |
Implemented in CMSwapCurveState, CoterminalSwapCurveState, and LMMCurveState.
|
pure virtual |
Implemented in CMSwapCurveState, CoterminalSwapCurveState, and LMMCurveState.
Implemented in CMSwapCurveState, CoterminalSwapCurveState, and LMMCurveState.
Definition at line 32 of file curvestate.cpp.
|
pure virtual |
Implemented in CMSwapCurveState, CoterminalSwapCurveState, and LMMCurveState.
|
protected |
Definition at line 84 of file curvestate.hpp.
|
protected |
Definition at line 85 of file curvestate.hpp.
|
protected |
Definition at line 85 of file curvestate.hpp.


@* * 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 config.FrontendAppConfig @this( main_template: main_template ) @(appConfig: FrontendAppConfig)(serviceInfoContent: Option[Html])(implicit request: Request[_], messages: Messages) @main_template( Messages("new.yourSelfEmployedTaxReturnTranscript.title"), appConfig = appConfig, bodyClasses = None, serviceInfoContent = serviceInfoContent ) { @components.heading("new-yourSelfEmployedTaxReturnTranscript-heading", "new.yourSelfEmployedTaxReturnTranscript.heading", "govuk-heading-xl")
@messages(s"new.yourSelfEmployedTaxReturnTranscript.paragraph1")
@messages(s"new.yourSelfEmployedTaxReturnTranscript.paragraph2") @messages("help_and_contact.govuk_link") @messages(s"new.yourSelfEmployedTaxReturnTranscript.paragraph2_2")
@messages(s"new.yourSelfEmployedTaxReturnTranscript.paragraph3")
@messages(s"new.yourSelfEmployedTaxReturnTranscript.paragraph4") @messages("help_and_contact.govuk_link") @messages(s"new.yourSelfEmployedTaxReturnTranscript.paragraph4_2")
@messages(s"new.yourSelfEmployedTaxReturnTranscript.paragraph5")
@messages(s"new.yourSelfEmployedTaxReturnTranscript.paragraph6")
@messages(s"new.yourSelfEmployedTaxReturnTranscript.paragraph7") @messages("help_and_contact.govuk_link") @messages(s"new.yourSelfEmployedTaxReturnTranscript.paragraph7_2")
@messages(s"new.yourSelfEmployedTaxReturnTranscript.paragraph8")
@messages(s"new.yourSelfEmployedTaxReturnTranscript.paragraph9")
@messages(s"new.yourSelfEmployedTaxReturnTranscript.paragraph10")
@messages(s"new.yourSelfEmployedTaxReturnTranscript.paragraph11")
@messages(s"new.yourSelfEmployedTaxReturnTranscript.paragraph12")
@messages(s"new.yourSelfEmployedTaxReturnTranscript.paragraph13")
@messages(s"new.yourSelfEmployedTaxReturnTranscript.paragraph14") @messages("help_and_contact.govuk_link") @messages(s"new.yourSelfEmployedTaxReturnTranscript.paragraph14_2")
}


Still lifes are works of art that feature mostly inanimate subject matter, typically commonplace objects are either natural (food and flowers are popular) or human-made.
Wikipedia says: “With origins in the Middle Ages and Ancient Greco-Roman art, still-life painting emerged as a distinct genre and professional specialization in Western painting by the late 16th century, and has remained significant since then. A still-life form gives the artist more freedom in the arrangement of elements within a composition than do paintings of other types of subjects such as landscape or portraiture.”


More Recipes
Register
SignUp/SignIn
×
SignIn
SignUp
Email address
Password
Submit
Username
Email
Password
Confirm Password
Submit
Amazing Recipes at your fingertips
Search
All
Most Favourited
Jollof Rice
Jollof Rice
Jollof Rice
Jollof Rice
Jollof Rice
Jollof Rice
Previous
1
2
3
Next


“Ruby on Rails is a breakthrough in lowering the barriers of entry to programming.
Powerful web applications that formerly might have taken weeks or months
to develop can be produced in a matter of days.”
-Tim O'Reilly, Founder of O'Reilly Media
Read more quotes
“Rails is the most well thought-out web development framework I’ve ever used.
And that’s in a decade of doing web applications for a living. I’ve built my
own frameworks, helped develop the Servlet API, and have created more than
a few web servers from scratch. Nobody has done it like this before.”
-James Duncan Davidson, Creator of Tomcat and Ant
Read more quotes
“It is impossible not to notice Ruby on Rails. It has had a huge effect both in
and outside the Ruby community... Rails has become a standard to which even
well-established tools are comparing themselves to.”
-Martin Fowler, Author of Refactoring, PoEAA, XP Explained
Read more quotes
“What sets this framework apart from all of the others is the preference for
convention over configuration making applications easier
to develop and understand.”
-Sam Ruby, ASF board of directors
Read more quotes
“Before Ruby on Rails, web programming required a lot of verbiage, steps and time.
Now, web designers and software engineers can develop a website
much faster and more simply, enabling them to be more productive
and effective in their work.”
-Bruce Perens, Open Source Luminary
Read more quotes
“After researching the market, Ruby on Rails stood out as the best choice.
We have been very happy with that decision. We will continue
building on Rails and consider it a key business advantage.”
-Evan Williams, Creator of Blogger and ODEO
Read more quotes
“Ruby on Rails is astounding.
Yukihiro Matsumoto, Creator of Ruby
Read more quotes


Master Cardien:
Soon our tribe shall face a mortal challenge. The Mother Tree is dying... We must prevent this at all costs! .
Hierarch Asterios has called for the young Elves to gather in the Elven Forest. Soon you will return to your homeland, but you must gain more experience first.
(Quest for Elven characters level 37 and above.)


Princess Nokia Shares New "Balenciaga" Track
Princess Nokia debuts NSFW "Balenciaga" video.
by Milca P.Balenciaga
Princess Nokia
Editor Rating: HOTTTTT
User Rating: meh - 54% (6)
Princess Nokia has dropped off her newest track, "Balenciaga," offering a lyrical argument against social media's ills. On the track, Nika makes a case against dressing for "likes," and promotes the act of dressing for oneself. She even takes things a step further by literally shedding off layers of designer in an accompanying NSFW clip.
“This song is about the fun I’ve always had taking designer concepts and recreating them with imagination and personality,” Nokia revelaed in a statement. “It’s about weird, off-kilter fashion and the blurred lines between fashion and style. It’s not anti-designer at all…it’s just a song about practicality and comfortability with one’s self. It’s about non-conformity and not taking fashion too seriously. The underlying theme I realized was about not caring what people think and dressing for yourself.”
Listen below.
Quotable Lyrics
Sketchers lookin' like Balenciaga
Thrift clothes lookin' like the Prada
Whole fit lit, it cost me nada
Bitches always talkin', I give them all nada


There are many variations of passages of Lorem Ipsum available, but the majority have suffered lobbied alteration in some Redid form


Ripple Director of Product Launches XRP Entertainment Marketplace for Music
by Daily Hodl StaffRipple’s director of product is rolling out a new digital marketplace that will allow musicians to sell their songs online for XRP.
Called “xSongs,” the platform utilizes Payburner, an integrated payment system built on top of the XRP Ledger, says Craig DeWitt.
There’s no fee to upload or post songs, and musicians will receive 100% of the revenue from their sales through peer-to-peer XRP payments.
The marketplace won’t support legacy payment methods and allows creators to set their own price.
DeWitt says the short-term goal of the platform is not to make money, but to create a thriving product that increases the usability of XRP.
“If you can build a product that drives significant value to the market, monetization will not be a problem.
Uber loses money on ever [sic] ride they give, but they’ve built something incredibly valuable.”
The project is currently in beta for the uploading/publishing side of the marketplace, which includes a wallet and the ability to manage music.
“Once we’ve gotten enough music uploaded and finished building the front end marketplace, we’ll turn on the purchasing side of xSongs.
This will be the front end to allow anyone to buy songs.”
That’ll likely happen in a few weeks, after the publishing build-up phase concludes, according to the Ripple executive.


[viewBag] title = "Pastor" url = "/about-us/pastor" layout = "default" hidden = "0" navigation_hidden = "0" seo_description = "Find out about our pastor, Mark Drury" robot_index = "index" robot_follow = "follow" ==
Our Pastor, Mark Drury, originates from Suffolk. He obtained a degree in Applied Theology at Moorlands Bible College before becoming trainee pastor at Beccles Baptist Church in Suffolk. He joined us in Crockenhill in 2011, but before this he served in a number of churches in different roles in Essex and Suffolk. He is married to Joanne and they have a daughter called Naomi. Mark enjoys reading, seeing Ipswich Town win at football, skiing, sport, decorating, gardening and spending quality time with his family.
He can be reached by phone on 01322 663995, or by email at pastor@crockenhill.org.


Instructions
- Go to the nearest OXXO store. Find it here.
- Tell the cashier that you want to make an OXXOPay payment.
- Dictate the cashier the reference number on this stub.
- Make the payment with cash.
- To confirm your payment, the cashier will hand you a printed receipt. Check on it that it was performed correctly.


OSC (OpenSoundControl, http://opensoundcontrol.org/) is a communication protocol which allows you to share (typically music performance) data in real-time over a network. OSC is similar to MIDI and allows musical instruments, controllers and multimedia devices but also software to communicate via a standard home or studio network (TCP/IP, ethernet) or via the internet.
Some PlotDevice libraries already use OSC (wiiNode, Reactivivision) but we thought it might be useful as a library in itself.
| OSC.zip (1210KB ) Last updated for NodeBox 1.9.4 Licensed under the GPL Authors: Daniel Holth, Clinton McChesney, ixi-software Examples/EMG |
Put the ‘osc’ library folder in the download in the same folder as your script so PlotDevice can find the library. You can also put it in ~/Library/Application Support/PlotDevice/.
osc = ximport("osc")
Have a look at test.py to see a simple ’pure-data talks to
plotdevice and back’ example.
Before sending or receiving data OSC should be initialized. The process initializes the callback manager and the out-socket.
osc.init()
Sending data over osc has different possibilities. You can send a single message or a bundle
that stores several messages.
A single message:
message = osc.createBinaryMsg(osc_address, data_list)
osc.sendOSC(message, ip_address, port)
or in one line:
osc.sendMsg(osc_address, data_list, ip_address, port)
As for bundles, the above can be used because the data sent is a list that can contain more than one message. There are options to create and send a bundle in a different way.
Methods for making a bundle, adding items to it and sending it:
bundle = osc.createBundle()
osc.appendToBundle(bundle, osc_address, data_list)
osc.sendBundle(bundle, ip_address, port)
To receive data over OSC an in-socket should be set up.
in_socket = osc.createListener(ip_address, port)
The in-socket can be used to get incoming OSC to send it to the callback manager.
osc.getOSC(in_socket)
A final command can bind OSC addresses with commands in the sketch.
osc.bind(plotdevice_command, osc_address)
OSC has been implemented in a variety of software. The library contains a few examples in Pure Data and Processing but many other applications like Max, Quartz Composer, Bidule have OSC-implementations. For a full list go to this page.


Web Capture
Upload Image:
Save files as username.png and upload to
uploadface.html
Tiny Face Detector
SSD Mobilenet V1
MTCNN
Select Face Detector
Get image from math server URL:
Ok
Min Confidence:
-
+
Input Size:
160 x 160
224 x 224
320 x 320
416 x 416
512 x 512
608 x 608
Input Size
Score Threshold:
-
+
Minimum Face Size:
-
+


Black and Grey Tattoo's
Fillipe Pacheco only does black and grey portraits, no exceptions. You must leave a $150 deposit through paypal within 24 hrs of setting the appointment. All deposits come out of the price of the tattoo. You must give 1 week notice for a cancellation to receive your deposit back. If you have any other questions, please give us a call.
51-99658-6550
tradicionalarte@gmail.com


Habitat
Originally from the Kanto region, but also found in all other regions. They live in humid forests with many flowers. Where butterfree can be found, caterpies and metapods can be found.


Class: Mongoid::Association::One
- Defined in:
- lib/mongoid/association/one.rb
Overview
This is the superclass for one to one relations and defines the common behavior or those proxies.
Direct Known Subclasses
Embedded::EmbeddedIn::Proxy, Embedded::EmbedsOne::Proxy, Referenced::BelongsTo::Proxy, Referenced::HasOne::Proxy
Instance Attribute Summary
Attributes inherited from Proxy
#_association, #_base, #_target
Instance Method Summary collapse
-
#__evolve_object_id__ ⇒ Object
Evolve the proxy document into an object id.
-
#clear ⇒ true, false
Clear this relation - same as calling #delete on the document.
-
#in_memory ⇒ Array<Document>
Get all the documents in the relation that are loaded into memory.
-
#respond_to?(name, include_private = false) ⇒ true, false
Since method_missing is overridden we should override this as well.
Methods inherited from Proxy
apply_ordering, #extend_proxies, #init, #klass, #reset_unloaded, #substitutable
Methods included from Marshalable
Dynamic Method Handling
This class handles dynamic methods through the method_missing method in the class Mongoid::Association::Proxy
Instance Method Details
#__evolve_object_id__ ⇒ Object
Evolve the proxy document into an object id.
57 58 59 |
# File 'lib/mongoid/association/one.rb', line 57 def __evolve_object_id__ _target._id end |
#clear ⇒ true, false
Clear this relation - same as calling #delete on the document.
19 20 21 |
# File 'lib/mongoid/association/one.rb', line 19 def clear _target.delete end |
#in_memory ⇒ Array<Document>
Get all the documents in the relation that are loaded into memory.
31 32 33 |
# File 'lib/mongoid/association/one.rb', line 31 def in_memory [ _target ] end |
#respond_to?(name, include_private = false) ⇒ true, false
Since method_missing is overridden we should override this as well.
45 46 47 |
# File 'lib/mongoid/association/one.rb', line 45 def respond_to?(name, include_private = false) _target.respond_to?(name, include_private) || super end |


The following are excerpts from the “Decadal Survey” relevant to the
HPDE. Even if the DRIVE initiative
is not funded beyond current levels of effort, these recommendations can provide
a guide for future efforts.
Solar and Space Physics: A Science for a
Technological Society (2013)
Committee on a Decadal Strategy for Solar and
Space Physics (Heliophysics); Space Studies Board; Aeronautics and Space
Engineering Board; Division of Earth and Physical Sciences; National Research
Council
A relatively small, low-cost initiative, DRIVE provides high leverage to
current and future space science research investments with a diverse set of
science-enabling capabilities. The five DRIVE components are as follows:
•
Diversify
observing platforms with microsatellites and midscale ground-based assets.
•
Realize scientific
potential by sufficiently funding operations and data analysis.
•
Integrate
observing platforms and strengthen ties between agency disciplines.
•
Venture
forward with science centers and instrument and technology development.
•
Educate,
empower, and inspire the next generation of space researchers.
R1.0 Implement the DRIVE Initiative
The survey committee recommends implementation of
a new, integrated, multiagency initiative (DRIVE— Diversify, Realize,
Integrate, Venture, Educate) that will develop more fully and employ more
effectively the many experimental and theoretical assets at NASA, NSF, and
other agencies.
DRIVE, part 2:
Realize: Realize
Scientific Potential by Sufficiently Funding Operations and Data Analysis
The value of a mission or ground-based investigation is only
fully realized, and science goals only achieved, if the right measurements are
performed over the mission’s lifetime and new data are analyzed fully (see Figure
4.3). Realizing the full scientific potential of solar and space physics assets
therefore requires investment in their continuing operation and in effective
exploitation of data (see Box 4.1). Furthermore, a successful investigation
should also include a focused data analysis program (see Box 4.2) that supports
science goals that may span platforms or change throughout a mission. The
following program augmentations expand the potential for new discoveries from
data.
Box 4.1:
Data Exploitation
Significant progress has been made over the last decade in
establishing the essential components of the solar and space physics data
environment. However, to achieve key national research and applications goals,
a data environment that draws together new and archived satellite and
ground-based solar and space physics data sets and computational results from
the research and operations communities is needed. As discussed in more detail
in Appendix B: Instrumentation, Data Systems, and Technology, such an environment
would include:
• Coordinated development of a
data systems infrastructure that includes data systems software, data analysis
tools, and training of personnel;
• Community oversight of emerging,
integrated data systems and inter-agency coordination of data policies;
• Exploitation of emerging
information technologies without investment in their initial development;
• Virtual observatories as a
specific component of the solar and space physics research-supporting
infrastructure, rather than as a direct competitor for research funds;
• Community-based development of
software tools, including data mining and assimilation;
• Semantic technologies to enable
cross-discipline data access.
End Box 4.1
DRIVE: Integrate: Integrate
Observing Platforms and Strengthen Ties Between Agency Disciplines
Coordinated Observations
Data from diverse space- and
ground-based instruments need to be routinely combined in order to maximize
their multiscale potential. In fact, such coordinated investigations are likely
to be a crucial element of future breakthrough science and to provide new
pathways for translating scientific knowledge into societal value. The idea of
coordinating multiscale observations resonates both with the types of
system-science questions identified by the survey’s disciplinary panels and
with the Heliophysics Science Centers described in the next section (Venture).
Examples might include extending “World Day” coordination of NSF radars to
other ground-based and mission data collections, combining data from CubeSat
arrays and larger spacecraft, GPS receiver hosting, development of distributed
arrays of ground- based instruments (potentially funded by an NSF mid-scale
program), and ground-based and space mission solar observational support for
the ATST (see Appendix C: Suborbital Platforms and Small Explorers).
Recommendation: NASA, NSF, and other agencies should coordinate
ground- and space-based solar-terrestrial observational and technology programs
and expand efforts to take advantage of the synergy gained by multiscale
observations.
(Appendix) B.3 DATA SYSTEMS
Data from NASA’s heliophysics missions and many ground-based
observatories can be obtained currently through the web, either directly from
individual sites or through central archives such as the Solar Data Analysis
Center (SDAC), Space Physics Data Facility (SPDF), or National Space Science
Data Center (NSSDC). These data archives are also accessible through Virtual
Observatories (VxOs), whose goals are to provide one-stop access to validated science
data from many observatories, along with the necessary tools for cross-mission
analysis and visualization. Access to sophisticated modeling tools is provided
by repositories, such as the Community Coordinated Modeling Center (CCMC). Such
agency-sponsored facilities host physics-based or empirical models developed by
the user community and allow users to perform their own simulations.
B.3.1 Current Status
Significant progress has been made over past decade in
defining the fundamental components of the data environment (Virtual
Observatories, Archives, etc.) and in starting to build and integrate them.
However there continues to be a dearth of tools for using and analyzing data.
However, projected data requirements for new projects are not as demanding as
the leap from SOHO to SDO. New requirements can probably be met with existing
technologies and software. For instance, daily generation of ATST data in 2018
is estimated to be ~4 TB, about same as the current SDO export rate. It is also
noted that some segments of the research community still suffer from the lack
of effective data policies enforced by sponsoring agencies.
Data systems supporting heliophysics research over the past
decade have evolved from stand- alone, custom-built “stove-pipes” to distributed,
interacting systems that leverage software and technologies developed by the
community. Much of this welcome development has come through NASA’s
Heliophysics Data Environment (HPDE) Enhancement and NSF’s CISE and Cyber
infrastructure. Many heliophysics datasets and models are hosted at multiple
data archives and modeling centers, each with different architectures and
formats. And much of the work on data systems infrastructure is funded through
individual PI teams. This results in uncoordinated software development,
unpredictable support lifecycle, and data analysis tools with limited scope.
Such activity also draws funds and focus away from scientific research and
analysis activities, since investigators are obliged to provide data sets and
analysis tools as deliverables. Unfortunately, many of the existing archives,
modeling centers, and VxOs are not inter-compatible, despite significant
overlap in content or access.
The current lack of coordination among data and modeling
centers stems mainly from their different philosophies, emphases, formats,
architectures, and purposes. One can obtain similar datasets from various
nationally funded data archives, as well as from VxOs. The existence of duplicative capabilities, each with significantly
different purpose and implementation philosophy, provides greater, more
flexible access at the cost of generating confusion about which path to follow
to the data. National and international agencies have not identified a common
goal nor have they adopted a standard approach for funding and implementing
data facilities and archives.
Current modeling centers, such as the CCMC, have multiple
sponsors and allow researchers to run simulations using community-provided
models that cover vastly different domains such as the solar corona, the solar
wind, the radiation environment in the heliosphere and Earth’s radiation belts,
and the magnetic and electric field environments of the magnetosphere and
ionosphere. Although some space weather modeling groups have developed end-to-end
models, often the component modules employ controversial techniques and are
based on assumptions with inherent strengths and weaknesses. Only a small
fraction of all models can be run interactively, and even fewer can be coupled.
This makes it difficult to validate different models and to model interesting
space weather events.
B.3.2 Future Goals and Directions
Heliophysics is poised to make a natural transition from
being driven predominantly by the pursuit of basic scientific understanding of
physical processes towards one that must also address more operational,
application-specific needs, much like terrestrial weather forecasting. This transition requires (1) instant
unfettered access to a wide array of datasets from distributed sources in a uniform,
standardized format, (2) incorporation of the results of community-developed
models, and (3) the ability to perform simulations interactively and to couple
different models to track ongoing space-weather events.
NASA has already taken the important first step in
integrating many of these datasets and tools to form the Heliophysics Data
Environment (HPDE). The main objective of the HPDE is to implement a
distributed, integrated, flexible data environment. HPDE modeling centers
should serve as a sound foundation for a future, fully integrated heliophysics
data and modeling center.
The key
ingredients necessary for any successful centralized data and modeling
environment are (1) full involvement of data providers, (2) rapid, open access
to scientifically validated data, (3) peer-reviewed data systems driven by
community needs and standards, (4) coordinated, user friendly analysis tools,
(5) reliable high-performance computing facilities and data storage, (6)
uniform terminology and adequate documentation describing data products and
sources, (7) flexible, interoperable, and inter-connected data archives,
modeling centers, and VxOs, and (8) effective communication among data
providers, national and international partners, and data users.
The tremendous quantity of heliophysics data that will
become available in the next decade will strain the financial, personnel,
hardware, and software resources available to individual scientists, teams, and
even national agencies. The dramatic advances in computing and data storage
technology over the last decade are likely to continue, so the cost of future
data systems and modeling centers will be dominated by personnel and software
development rather than securing ultra-fast computing or data storage. To
achieve these goals efficiently, the national agencies will need to develop a
common approach for funding data facilities, archives, modeling centers, and
VxOs and coordinate the development of data systems infrastructure that
includes the development of data systems software, data analysis tools, and
training personnel.
B.3.3 Opportunities in New Data Systems B.3.3.1 Community
Input to and Control of the Integrated Data Environment
A number of virtual observatory and other data
identification and access tools have appeared or are under development. These efforts could be strengthened, better
focused, and more efficiently managed if more user feedback were incorporated
into their governance, perhaps by formalizing community oversight of such
emerging, integrated data systems in an ad hoc group such as the NASA
Heliophysics Data and Computing Working Group. Interagency coordination of
the data environment as a whole would benefit researchers whose efforts are
funded by multiple agencies.
B.3.3.2 Emerging Technologies
The IT industry continues to generate novel technologies and
capabilities faster than any federally funded, competitively sourced research
program can hope to match. Agencies must be agile enough to exploit emerging
technologies without investing in their original development. The best approach is to (1) focus on
commercially viable technologies for which there is a demonstrated need, such
as high performance computing clusters, and (2) otherwise invest modestly in
the evaluation of emerging commercial technologies through existing mission and
small-scale data center activities.
B.3.3.3 Virtual Observatories
NASA has funded virtual observatories and related
“middleware” development. Some of these have led to useful targeted data
identification and access technologies, and some are still under development.
Mature capabilities should not continue to compete with research proposals for
funding. A more effective approach would
be for NASA and its agency partners to establish a heliophysics-wide data
infrastructure; selecting the most useful efforts for stable funding and
bringing other efforts to a close. Future developments can be managed
through the supplemental funding mechanisms discussed in sections B.3.3.2 or
B.3.3.4.
B.3.3.4 Community-Based Software Tools
In a few sub-disciplines, such as solar physics, availability
of integrated open-source data reduction
and analysis tools make a significant difference in the ability of
researchers to access and manipulate data. In
areas where such tools are not available, immediate agency investment in
community-based development would be highly productive. Where tools are already
available, support to maintain and evolve them as new data sets and
capabilities emerge should continue. Capabilities should expand to include data
mining and assimilation in order to enable full exploitation of the large new
heliophysics datasets.
B.3.3.5. Semantic Technologies
The astrophysics and geophysics communities have taken the
lead in adopting modern, “semantic” technologies, where machines “understand”
the context and meaning of data, to enable cross- discipline data access.
Promoting the development of semantic technology would enable the emerging data
access capability in heliophysics to share data and knowledge with other
fields.
B.3.3.6 A National Approach to Data Policies
The heliophysics data policies of the funding agencies
differ, or are in some cases lacking. The NSF, for instance, now requires a
data management plan in all research proposals, but geosciences does not yet
have a uniform data access and preservation policy. NASA Heliophysics has a well developed data management policy, but
long-term preservation of data is in a state of flux. It would be wise for the
agencies to formulate a national policy for curation of data from
taxpayer-funded scientific research. For heliophysics, the Committee on Space
Weather could review and monitor agency data policies.


OiL is an extensible component-based architecture for object request brokers (ORB). An ORB provides an infrastructure to perform remote method invocations (RMI) on objects residing in separated processes, possibly through a network. The use of an ORB is one of the most common ways to develop distributed object-oriented applications. OiL is provided as a <%=link("LuaManual.Modules", "Lua module")%> that can be required by the following command:
require "oil"
OiL provides a very flexible ORB implementation and almost every one of its aspects can be changed by replacement of its components (see the <%=link"Architecture"%>). Nevertheless, OiL relies on three fundamental concepts that define the programming model supported:
An essential feature common in almost every ORB is the support for multithreading. OiL supports a cooperative multithreading model which is implemented over the coroutines provided by Lua. This model of multithreading is fundamentally different from preemptive multithreading, which is supported by most modern platforms. For a complete discussion about the multithreading model supported by standard OiL see section <%=link"Threads"%>.


Examples
Hello, world!
Firstly, the canonical ‘Hello World’ example: (If you would like to see the output, it might be a good idea to have a 16×2 LCD shield such as this is connected.)
(include "libraries/list.ms")
(include "libraries/io.ms")
(include "libraries/lcd.ms")
(lcd_init)
(for-each-vector print "Hello, World!")
Interacting with the world
Using the general purpose digital input/output pins on the arduino is simple. Assuming you are using an Arduino MEGA, and have an LED connected to digital pin 20, you can make it blink like so:
(include "libraries/io.ms")
(set-ddr 20 #t) ; Set direction register for pin 20 to 'output'
(define (blink_forever)
(set-pin 20 #t) ; Set pin 20 high
(pause 500) ; Wait half a second
(set-pin 20 #f) ; Set pin 20 low
(pause 500) ; Wait half a second
(blink_forever)) ; Repeat...
(blink_forever)
Fibonacci Sequence
In the next example, we build a list of numbers from the Fibnacci sequence. This time, rather than producing output on an LCD screen, we send each of the values to some external device via the serial interface.
(include "libraries/list.ms")
(define (fibstep i acc n2 n1)
(if (= 0 i)
acc
(fibstep (- i 1) (cons (+ n2 n1) acc) n1 (+ n2 n1))))
(define (fib n)
(reverse (fibstep n () 0 1)))
(for-each serial-send (fib 10))
Factorial
Here we see two approaches to writing a factorial function; the second of which is tail-recursive. In each function, the value of (stacksize)
, which returns the number of bytes occupied at the moment of evaluation, is reported at the deepest part of the recursion. This demonstrates the importance of the tail-recursive style in environments such as microcontrollers.
(include "libraries/list.ms")
(define (factorial n)
(if (zero? n)
(begin (serial-send (stacksize)) 1)
(* (factorial (- n 1)) n)))
(serial-send (factorial 7))
(define (tail-factorial n acc)
(if (zero? n)
(begin (serial-send (stacksize)) acc)
(tail-factorial (- n 1) (* acc n))))
(serial-send (tail-factorial 7 1))


{% extends "global/Page.html" %} {% load otree %} {% block title %} ¡Thank you for being part of this study! Now its time to give you your Completion Code {% endblock %} {% block content %}
Your Completion Code is below, but for it to count, you must write it.
{{RandomNumber}}
{% formfield player.Code %}
{% next_button %} {% endblock %}


Fantasia Promenade returns with Tony Hadley and Peter Andre
by Jake FoxfordA waterfront concert in Essex is bringing the likes of Tony Hadley, Peter Andre, S Club and supergroup Boyzlife together for a huge summer concert.
The music and light spectacular, Fantasia, is returning to the Maldon Promenade on July 25 next year having brought more than 10,000 to the Essex town in the 2000s.
Now returning in 2020, the show will be headlined by Tony Hadley of Spandau Ballet fame, now performing solo, and bringing a back catalogue of hits including Gold, True and Through The Barricades.
Also performing are supergroup Boyzlife, featuring Boyzone's Keith Duffy and Westlife's Brian McFadden, as well as both bands biggest hits.
Joining them are hit-makers from across the decades, including 70s soul outfit Odyssey, who are still going strong more than 40 years after forming.
Peter Andre will be at the park, best known for his iconic single, Mysterious Girl, along with the reformed S Club, with three of the original line-up (Jo, Bradley and Tina) performing the group's much-loved noughties pop songs.
On top of those, the show features two top tributes, The Absolute Bowie Band and Spice Girls tribute Wannabe,
Stitching the show together will be host Rylan Clark-Neal, who is currently dazzling audiences with his smile on BBC Two's Strictly Come Dancing chat show, It Takes Two.


Keyboard Layout Editor
Decimal
Hex
Name
Matrix Position
Filter
Code
Hex
Name
Comment
Matrix Element (Row/Column):
Nothing yet
Selected:
Nothing yet
Keycode:
Set
Enter your layout here
Set layout


The org.sgiusa.model package contains the following elements.
The following protection mechanisms are configured for the org.sgiusa.model package.


ICY HOT MEDICATED NO MESS APPLICATOR- menthol liquid
Chattem, Inc.
Disclaimer: Most OTC drugs are not reviewed and approved by FDA, however they may be marketed if they comply with applicable regulations and policies. FDA has not evaluated whether this product complies.
temporarily relieves minor pain associated with:
For external use only
adults and children over 12 years:
children 12 years or younger: ask a doctor
acrylates/C10-30 alkyl acrylate crosspolymer, capsaicin, glycerin, isopropyl myristate, propylene glycol, SD alcohol 40 (30%), water (245-256)
Close cap tightly after use. Keep carton as it contains important information.
Distributed by Chattem, Inc.
P.O. Box 2219
Chattanooga, TN 37409-0219
U.S.A ©2010 www.icyhot.com Recyclable Carton
|
ICY HOT MEDICATED NO MESS APPLICATOR
menthol liquid | ||||||||||||||||||||
| ||||||||||||||||||||
| ||||||||||||||||||||
| ||||||||||||||||||||
| ||||||||||||||||||||
|
| Labeler - Chattem, Inc. (003336013) |
| Establishment | |||
| Name | Address | ID/FEI | Business Operations |
|---|---|---|---|
| Chattem Plant 1 | 003336013 | ANALYSIS, LABEL, MANUFACTURE, PACK, RECOVERY, RELABEL, REPACK |
| Establishment | |||
| Name | Address | ID/FEI | Business Operations |
|---|---|---|---|
| Chattem Plant 2 | 830410721 | LABEL, MANUFACTURE, PACK, RECOVERY, RELABEL, REPACK |


--- layout: page title: Research ---
Data assimilation (DA) refers to techniques used to combine the data from physics-based, numerical models and real-world observations to produce an estimate for the state of a time-evolving random process and the parameters that govern its evolution. Owing to their history in numerical weather prediction, DA systems are designed to operate in an extremely large dimension of model variables and observations, often with sequential-in-time observational data. As a long-studied “big-data” problem, DA has benefited from the fusion of a variety of techniques, including methods from Bayesian inference, dynamical systems, numerical analysis, optimization, control theory and machine learning. I am developing data assimilation methodology for the prediction of atmospheric rivers and other extreme precipitation events in the Western USA.
Please find my computational resources and pre-prints linked below by subject area.
This is a data assimilation research code base with an emphasis on prototyping, testing and validating sequential filters and smoothers in toy model twin experiments. This code is meant to be performant in the sense that large hyper-parameter discretizations can be explored to determine hyper-parameter sensitivity and reliability of results across different experimental regimes, with parallel implementations in native Julia distributed computing and using workload managers such as Slurm.
Example code for the algorithms developed in our project and toy data can be found in my github Electric Grid Code Repository . Visualizations are linked below.
The following visualizations demonstrate the force directed layout of the fully reduced power grid network model, where nodes represent repelling bodies and edges represent springs. We randomly initialize the positions for the triangle reduced network and run the positions to a stabilized configuration. Random initial positions are shown in the first figure and a stabilized result is shown in the second. Finally, we overlay the degree two reduction (performed before the triangle reductions) on the positions for the stabilized triangle reduction. Enabling the physics on the third figure demonstrates the declustering of the degree two reduced network from the triangle reduced network, as shown in the manuscript. These visualizations are best viewed in Chrome.