Class Map
Methods
| map:init (width, height, gridOnly) | Initiates a map. |
| map:clear (open, clearAll) | Completely clear everything from a map. |
| map:isClear (x, y, ctype, ignoreCreats, ignore_safety, projectile) | Checks whether a map tile is clear |
| map:isEmpty (x, y, ignoreCreats, lookAtBaseTile) | Checks whether a map tile is totally empty (not just open for movement) |
| map:get_contents (x, y) | Gets contents of a map tile |
| map:enter (x, y, creature, fromX, fromY) | Run the terrain enter() callbacks for the creature's location |
| map:can_see_through (x, y, args) | Determines if a given tile blocks vision |
| map:get_tile_creature (x, y, get_attackable_features, ignoreNoDraw) | Gets what creature (if any) is on a tile |
| map:get_tile_features (x, y) | Gets a list of all features (if any) on a tile. |
| map:tile_has_feature (x, y, id) | Check if a tile has a specific feature |
| map:get_blocking_feature (x, y) | Returns the first feature that blocks movement |
| map:get_tile_items (x, y, getAdjacent) | Gets a list of all items (if any) on a tile. |
| map:get_tile_actions (x, y, user, noAdjacent) | Gets a list of all feature actions (if any) available at and around a tile. |
| map:is_line (startX, startY, endX, endY, pass_through_walls, ctype, ignoreCreats, ignoreSafety) | Determines if you can draw a straight line between two tiles. |
| map:get_line (startX, startY, endX, endY, pass_through_walls, ctype, ignoreCreats, ignoreSafety) | Gets a line between two tiles, stopping when you encounter an obstacle. |
| map:get_tile_effects (x, y) | Gets all effects (if any) on a tile. |
| map:tile_has_effect (x, y, id) | Check if a tile has a specific effect on it |
| map:add_creature (creature, x, y, ignoreFunc) | Add a creature to a tile |
| map:add_feature (feature, x, y, args) | Add a feature to a tile |
| map:add_effect (effect, x, y) | Add an effect to a tile |
| map:add_item (item, x, y, ignoreFunc) | Add an item to a tile |
| map:change_tile (feature, x, y) | Set a map tile to be a certain feature |
| map:findPath (fromX, fromY, toX, toY, cType, terrainLimit) | Find a path between two points |
| map:touching (fromX, fromY, toX, toY) | Check if two tiles are touching |
| map:swap (creature1, creature2) | Swap the positions of two creatures. |
| map:refresh_pathfinder (cType, terrainLimit, ignoreSafety) | Refresh a pathfinder on the map |
| map:clear_all_pathfinders () | Delete all the pathfinders from the map |
| map:is_passable_for (x, y, cType, include_effects, ignore_safety) | Checks if a tile is passable for a certain creature |
| map:refresh_images () | Refresh all the tile images on the map |
| map:refresh_tile_image (x, y) | Refresh a specific tile's tile image |
| map:in_map (x, yNumber., exclude_borders) | Checks if a tile is within the map boundaries |
| map:refresh_lightMap (true) | Refresh the light map of the map. |
| map:refresh_light (light, forceRefresh) | Refresh the light map based on a light-emitting entity's light. |
| map:is_lit (x, y) | Checks if a tile is lit. |
| map:clear_tile (x, y) | Delete everything from a tile |
| map:reveal () | Mark every tile on the map as "seen" (the whole map will be revealed, but won't see creatures and effects outside of LOS) |
| map:get_creature_list (self, force, allowAll) | Get a list of possible creatures to spawn on this map. |
| map:get_item_list (self, force, allowAll) | Get a list of possible items to spawn on the given map |
| map:get_store_list (self, force) | Get a list of possible stores to spawn on the given map. |
| map:get_faction_list (self, force) | Get a list of possible factions to spawn on the given map |
| map:populate_creatures (creatTotal, forceGeneric) | Randomly add creatures to the map |
| map:populate_items (itemTotal, forceGeneric) | Randomly add items to the map |
| map:populate_stores (forceGeneric) | Randomly add a store to the map. |
| map:populate_factions (forceGeneric) | Randomly add an appropriate faction to the map. |
| map:get_name (noBranch) | Gets the full name string of the map (eg The Wilds Depth 2: The Forest of Horror) |
| map:get_min_level () | Get the minimum creature level for this map |
| map:get_max_level () | Get the maximum creature level for this map |
| map:get_content_tags (tagType, noBranch) | Get a map's tags |
Methods
- map:init (width, height, gridOnly)
-
Initiates a map. Don't call this explicitly, it's called when you create a new map with Map(50,50).
Parameters:
- width Number. The width of the map
- height Number. The height of the map
- gridOnly Boolean. If set to true, then extra tables (eg creatures, lights, pathfinders) will not be created for the map (optional)
Returns:
-
Map. The map itself.
- map:clear (open, clearAll)
-
Completely clear everything from a map.
Parameters:
- open Boolean. If True, make the whole map open floor. Otherwise, fill it with walls. Optional
- clearAll Boolean. If True, also clear out the various sub-tables of the map
- map:isClear (x, y, ctype, ignoreCreats, ignore_safety, projectile)
-
Checks whether a map tile is clear
Parameters:
- x Number. The x-coordinate to check
- y Number. The y-coordinate to check
- ctype String. The creature type to use when checking if the tile is passable (optional)
- ignoreCreats Boolean. Whether to ignore creatures when considering a tile clear (optional)
- ignore_safety Boolean. Whether to ignore dangerous but transversable features (optional)
- projectile Boolean. Whether to consider the tile free for a projectile vs a creature.
Returns:
-
Boolean. Whether the tile is clear
- map:isEmpty (x, y, ignoreCreats, lookAtBaseTile)
-
Checks whether a map tile is totally empty (not just open for movement)
Parameters:
- x Number. The x-coordinate to check
- y Number. The y-coordinate to check
- ignoreCreats Boolean. Whether to ignore creatures when considering a tile empty (optional)
- lookAtBaseTile Boolean. Whether to count the base tile being a feature as "not empty" (optional)
Returns:
-
Boolean. Whether the tile is clear
- map:get_contents (x, y)
-
Gets contents of a map tile
Parameters:
- x Number. The x-coordinate
- y Number. The y-coordinate
Returns:
-
Table. A table of all the contents of the tile
- map:enter (x, y, creature, fromX, fromY)
-
Run the terrain enter() callbacks for the creature's location
Parameters:
- x Number. The x-coordinate
- y Number. The y-coordinate
- creature Creature. The creature entering the tile
- fromX Number. The x-coordinate the creature is leaving (optional)
- fromY Number. The y-coordinate the creature is leaving (optional)
Returns:
-
Boolean. Whether or not the tile can be entered
- map:can_see_through (x, y, args)
-
Determines if a given tile blocks vision
Parameters:
- x Number. The x-coordinate
- y Number. The y-coordinate
- args Unused for now, leave blank.
Returns:
-
Boolean. Whether or not the tile blocks vision
- map:get_tile_creature (x, y, get_attackable_features, ignoreNoDraw)
-
Gets what creature (if any) is on a tile
Parameters:
- x Number. The x-coordinate
- y Number. The y-coordinate
- get_attackable_features Boolean. Whether to include attackable features (optional, defaults to false)
- ignoreNoDraw Boolean. Whether creatures that have noDraw set will be included (optional, defaults to false)
Returns:
-
Entity or Boolean. Will be FALSE if there's nothing there.
- map:get_tile_features (x, y)
-
Gets a list of all features (if any) on a tile.
Parameters:
- x Number. The x-coordinate
- y Number. The y-coordinate
Returns:
-
A table of features (may be empty)
- map:tile_has_feature (x, y, id)
-
Check if a tile has a specific feature
Parameters:
- x Number. The x-coordinate
- y Number. The y-coordinate
- id String. The ID of the feature to check for.
Returns:
-
Boolean. Whether or not the tile has this feature
- map:get_blocking_feature (x, y)
-
Returns the first feature that blocks movement
Parameters:
- x Number. The x-coordinate
- y Number. The y-coordinate
Returns:
-
Boolean. Whether or not the tile has this feature
- map:get_tile_items (x, y, getAdjacent)
-
Gets a list of all items (if any) on a tile.
Parameters:
- x Number. The x-coordinate
- y Number. The y-coordinate
- getAdjacent Boolean. Whether to also look at adjacent tiles (optional, defaults to false)
Returns:
-
A table of items (may be empty)
- map:get_tile_actions (x, y, user, noAdjacent)
-
Gets a list of all feature actions (if any) available at and around a tile.
Parameters:
- x Number. The x-coordinate
- y Number. The y-coordinate
- user Creature. The user looking for actions. Optional, defaults to player
- noAdjacent Boolean. Whether to count adjacent tiles. Optional, defaults to false (ie adjacent tiles are counted)
Returns:
-
A table of items (may be empty)
- map:is_line (startX, startY, endX, endY, pass_through_walls, ctype, ignoreCreats, ignoreSafety)
-
Determines if you can draw a straight line between two tiles.
Parameters:
- startX Number. The x-coordinate of the first tile
- startY Number. The y-coordinate of the first tile
- endX Number. The x-coordinate of the second tile
- endY Number. The y-coordinate of the second tile
- pass_through_walls Boolean. Whether to ignore walls that block the line (optional)
- ctype String. The creature path type (eg flyer) (optional)
- ignoreCreats Boolean. Whether to ignore creatures that block the line (optional)
- ignoreSafety Boolean. Whether to ignore unsafe but transversable tiles that block the line (optional)
Returns:
-
Boolean. Whether or not you can draw the line.
- map:get_line (startX, startY, endX, endY, pass_through_walls, ctype, ignoreCreats, ignoreSafety)
-
Gets a line between two tiles, stopping when you encounter an obstacle.
Parameters:
- startX Number. The x-coordinate of the first tile
- startY Number. The y-coordinate of the first tile
- endX Number. The x-coordinate of the second tile
- endY Number. The y-coordinate of the second tile
- pass_through_walls Boolean. Ignore walls that block the line (optional)
- ctype String. The creature path type (eg flyer) (optional)
- ignoreCreats Boolean. Ignore creatures that block the line (optional)
- ignoreSafety Boolean. Ignore unsafe but transversable tiles that block the line (optional)
Returns:
-
A table full of tile values.
- map:get_tile_effects (x, y)
-
Gets all effects (if any) on a tile.
Parameters:
- x Number. The x-coordinate
- y Number. The y-coordinate
Returns:
-
A table of effects(may be empty)
- map:tile_has_effect (x, y, id)
-
Check if a tile has a specific effect on it
Parameters:
- x Number. The x-coordinate
- y Number. The y-coordinate
- id String. The ID of the effect to check for.
Returns:
-
Boolean. Whether or not the tile has this effect
- map:add_creature (creature, x, y, ignoreFunc)
-
Add a creature to a tile
Parameters:
- creature Creature. A specific creature object, NOT its ID. Usually a new creature, called using Creature('creatureID')
- x Number. The x-coordinate
- y Number. The y-coordinate
- ignoreFunc Boolean. Whether to ignore the creature's new() function (optional)
Returns:
-
Creature. The creature placed
- map:add_feature (feature, x, y, args)
-
Add a feature to a tile
Parameters:
- feature Feature. A specific feature object, NOT its ID. Usually a new feature, called using Feature('featureID')
- x Number. The x-coordinate
- y Number. The y-coordinate
- args Anything. Arguments to pass to the feature's new() code
Returns:
-
Feature. The feature added
- map:add_effect (effect, x, y)
-
Add an effect to a tile
Parameters:
- effect Effect. A specific effect object, NOT its ID. Usually a new effect, called using Effect('effectID')
- x Number. The x-coordinate
- y Number. The y-coordinate
Returns:
-
Effect. The effect added
- map:add_item (item, x, y, ignoreFunc)
-
Add an item to a tile
Parameters:
- item Item. A specific item object, NOT its ID. Usually a new creature, called using Item('itemID')
- x Number. The x-coordinate
- y Number. The y-coordinate
- ignoreFunc Boolean. Whether to ignore the item's new() function (optional)
- map:change_tile (feature, x, y)
-
Set a map tile to be a certain feature
Parameters:
- feature Feature or String. A specific feature object, NOT its ID. Usually a new feature, called using Feature('featureID'). OR text representing floor (.) or wall (#)
- x Number. The x-coordinate
- y Number. The y-coordinate
Returns:
-
Feature or String. The feature added, or the string the tile was turned into.
- map:findPath (fromX, fromY, toX, toY, cType, terrainLimit)
-
Find a path between two points
Parameters:
- fromX Number. The x-coordinate, tile 1
- fromY Number. The y-coordinate, tile 1
- toX Number. The x-coordinate, tile 2
- toY Number. The y-coordinate, tile 2
- cType String. The creature path type (eg flyer) (optional)
- terrainLimit String. Limit pathfinding to tiles with a specific feature ID (optional)
Returns:
-
A table of tile entries, or FALSE if there is no path.
- map:touching (fromX, fromY, toX, toY)
-
Check if two tiles are touching
Parameters:
- fromX Number. The x-coordinate, tile 1
- fromY Number. The y-coordinate, tile 1
- toX Number. The x-coordinate, tile 2
- toY Number. The y-coordinate, tile 2
Returns:
-
Boolean. If the tiles are touching.
- map:swap (creature1, creature2)
-
Swap the positions of two creatures.
Parameters:
- creature1 Creature. The first creature
- creature2 Creature. The second creature
- map:refresh_pathfinder (cType, terrainLimit, ignoreSafety)
-
Refresh a pathfinder on the map
Parameters:
- cType String. The creature path type (eg flyer) (optional)
- terrainLimit String. If you want to limit the pathfinder to a specific feature ID (optional)
- ignoreSafety Boolean. Whether to ignore hazards (optional)
- map:clear_all_pathfinders ()
- Delete all the pathfinders from the map
- map:is_passable_for (x, y, cType, include_effects, ignore_safety)
-
Checks if a tile is passable for a certain creature
Parameters:
- x Number. The x-coordinate
- y Number. The y-coordinate
- cType String. The creature path type (eg flyer) (optional)
- include_effects Boolean. Whether to include effects in the passable check (optional)
- ignore_safety Boolean. Whether to ignore dangerous but transversable tiles (optional)
Returns:
-
Boolean. If it's passable.
- map:refresh_images ()
- Refresh all the tile images on the map
- map:refresh_tile_image (x, y)
-
Refresh a specific tile's tile image
Parameters:
- x Number. The x-coordinate
- y Number. The y-coordinate
- map:in_map (x, yNumber., exclude_borders)
-
Checks if a tile is within the map boundaries
Parameters:
- x Number. The x-coordinate
- yNumber. The y-coordinate
- exclude_borders Boolean. Whether or not to exclude the tiles on the border of the map
- map:refresh_lightMap (true)
-
Refresh the light map of the map. Called every turn.
Parameters:
- true /false clear. Whether to clear all the lights
- map:refresh_light (light, forceRefresh)
-
Refresh the light map based on a light-emitting entity's light.
Parameters:
- light Entity. The light source to refresh
- forceRefresh Boolean. Whether to force the light to refresh its lit tiles
- map:is_lit (x, y)
-
Checks if a tile is lit.
Parameters:
- x Number. The x-coordinate
- y Number. The y-coordinate
Returns:
-
Boolean. If the tile is lit.
- map:clear_tile (x, y)
-
Delete everything from a tile
Parameters:
- x Number. The x-coordinate
- y Number. The y-coordinate
- map:reveal ()
- Mark every tile on the map as "seen" (the whole map will be revealed, but won't see creatures and effects outside of LOS)
- map:get_creature_list (self, force, allowAll)
-
Get a list of possible creatures to spawn on this map. Stores the list, so when this is called in the future it just returns the list.
Parameters:
- self Map. The map to check
- force Boolean. Whether to force recalculation of the creature list (otherwise will return the stored list if it's already been calculated)
- allowAll Boolean. If True, creatures with the specialOnly flag can still be chosen based on their tags/factions/types. If not, they won't be chosen (unless already listed specifically in the map/branch lists)
Returns:
-
Table or nil. Either a table of creature IDs, or nil if there are no possible creatures
- map:get_item_list (self, force, allowAll)
-
Get a list of possible items to spawn on the given map
Parameters:
- self Map. The map to check
- force Boolean. Whether or not to forcibly re-calculate it, rather than returning the pre-calculated value
- allowAll Boolean. If True, creatures with the specialOnly flag can still be chosen based on their tags/factions/types. If not, they won't be chosen (unless already listed specifically in the map/branch lists)
Returns:
-
Table or nil. Either a table of item IDs, or nil if there are no possible items
- map:get_store_list (self, force)
-
Get a list of possible stores to spawn on the given map.
Parameters:
- self Map. The map to check
- force Boolean. Whether or not to forcibly re-calculate it, rather than returning the pre-calculated value
Returns:
-
Table or nil. Either a table of faction IDs, or nil if there are no possible stores
- map:get_faction_list (self, force)
-
Get a list of possible factions to spawn on the given map
Parameters:
- self Map. The map to check
- force Boolean. Whether or not to forcibly re-calculate it, rather than returning the pre-calculated value
Returns:
-
Table or nil. Either a table of faction IDs, or nil if there are no possible factions
- map:populate_creatures (creatTotal, forceGeneric)
-
Randomly add creatures to the map
Parameters:
- creatTotal Number. The number of creatures to add. Optional, if blank will generate enough to meet the necessary density
- forceGeneric Boolean. Whether to ignore any special populate_creatures() code in the map's mapType. Optional
- map:populate_items (itemTotal, forceGeneric)
-
Randomly add items to the map
Parameters:
- itemTotal Number. The number of items to add. Optional, if blank will generate enough to meet the necessary density
- forceGeneric Boolean. Whether to ignore any special populate_items() code in the map's mapType. Optional
- map:populate_stores (forceGeneric)
-
Randomly add a store to the map. This only adds one store to the map
Parameters:
- forceGeneric Boolean. Whether to ignore any special populate_stores() code in the map's mapType. Optional
- map:populate_factions (forceGeneric)
-
Randomly add an appropriate faction to the map. This only adds one faction to the map, and only factions that haven't previously been placed
Parameters:
- forceGeneric Boolean. Whether to ignore any special populate_factions() code in the map's mapType. Optional
- map:get_name (noBranch)
-
Gets the full name string of the map (eg The Wilds Depth 2: The Forest of Horror)
Parameters:
- noBranch Boolean. Optional, if set to true, only returns the base name of the map without depth and branch info
- map:get_min_level ()
- Get the minimum creature level for this map
- map:get_max_level ()
- Get the maximum creature level for this map
- map:get_content_tags (tagType, noBranch)
-
Get a map's tags
Parameters:
- tagType String. The type of tag
- noBranch Boolean. If true, don't look at branch's tags


Getting Started
The Vagrant getting started guide will walk you through your first Vagrant project, and show off the basics of the major features Vagrant has to offer.
Before diving into your first project, please install Vagrant. And if you're curious what benefits Vagrant has to offer, you should also read the "Why Vagrant?" page.
The getting started guide will use Vagrant with VirtualBox, since it is free, available on every major platform, and built-in to Vagrant. After reading the guide though, don't forget that Vagrant can work with many other providers.
Up and Running
$ vagrant init precise32 http://files.vagrantup.com/precise32.box
$ vagrant up
After running the above two commands, you'll have a fully running virtual machine in VirtualBox running Ubuntu 12.04 LTS 32-bit. You can SSH into this machine with vagrant ssh
, and when you're done playing around, you can remove all traces of it with vagrant destroy
.
Now imagine every project you've ever worked on being this easy to set up.
With Vagrant, vagrant up
is all you need to work on any project, to install every dependency that project needs, and to setup any networking and synced folders so you can continue working from the comfort of your own machine.
The rest of this guide will walk you through setting up a more complete project, covering more features of Vagrant.


| Total Weight | 7% | |
| Sub-Weightages | ||
| Education level | 2.190% | 30% |
| Number of university/Colleges in 50 KMs | ||
| Above 5 | 100% | 2.190% |
| 4 | 75% | 1.64250% |
| 3 | 50% | 1.0950% |
| 2 | 25% | 0.54750% |
| below 2 | 0% | 0.000% |
| Total | ||
| Hospital | 2.92% | 40% |
| General Hospital Distance in KMs | ||
| within 10 | 100% | 2.920% |
| 10-25 | 75% | 2.19000% |
| 25-40 | 50% | 1.4600% |
| 40-50 | 25% | 0.73000% |
| above 50 | 0% | 0.000% |
| Total | ||
| Hotel/Motel | 2.190% | 30% |
| 3 star hotel/Guest house in KMs | ||
| within 5 | 100% | 2.190% |
| 5-10 | 75% | 1.64250% |
| 10-20 | 50% | 1.0950% |
| 20-40 | 25% | 0.54750% |
| above 40 | 0% | 0.000% |
| Total | ||
| Total | 100% |


Cocktails
List of cocktails
Cocktail name:
Cocktail ingredient:
Find cocktail
Image
Name
Category
Glass type
Instructions


Case 2: Both path-planning system and ultrasonic system worked
In this test, a carton was dropped into the path right after the first path planning,
so the path-planning system did not take it into consideration. Ultrasonic system
came out to handle this situation according to the decision flow.
|
|
|
| Picture of Test Field |
Plot shown in main station program |
- The green blocks were the obstacles detected by stereo camera.
- The black block was the obstacle detected by ultrasonic sensors.
It was manually drawn after the field test. The path segment digressing from
the red line indicated that the vehicle was once in real-time obstacle-avoidance mode.
- The red line was the path created by the path-planning system.
- The black line was the actual path of the vehicle.


Rock County Medical Examiner releases name of victim in Town of Avon crash
by Stephen CohnTOWN OF AVON, Wis. - The Rock County Medical Examiner's Department released the name of the victim in a Town of Avon crash on Saturday night.
According to a news release, Fred Nafzger, Jr., 62, of Juda, was pinned inside his car during a head-on crash overnight.
The chief deputy from the Rock County Sheriff's office says the crash happened around 6 p.m. Friday on West Highway 81 near West Beloit Newark road in the Town of Avon.
A 20-year-old driver of another SUV in the crash suffered serious injuries and is now in a Janesville hospital.


Our fundraising events take place three times throughout the year, providing a variety of ways to give and get involved in Lifeline's ministry.
Saturday, May 30, 2015
10:00 a.m.
Baptist Student Union
110 W. Normal
Kirksville, MO 63501
The Walk for Life is a great fundraiser for the entire family! You can walk as an individual or as a team of 4. Walkers raise pledges from family and friends prior to the event in support of their commitment to join us and walk two miles the day of the Walk. All proceeds raised go directly to support the free services Lifeline provides.
Save the Dates: November 5, 2015 & November 6, 2015
That’s right, we will be having two consecutive banquet nights this year due to having outgrown the banquet space. Attendees may choose to attend either Thursday or Friday night. More details on the banquet coming soon! Our speaker this year is Carol Everett!
Thanks to everyone that participated in this year’s Baby Botttle Blessing campaign held January 18 – February 15, 2015. We are still receiving bottles in and will be posting a grand total once everyone has turned their bottles back in. Than you to all of the churches and organizations that participated this year!


JSON Schema Lint is a JSON schema validator to help you write and test JSON Schemas that conform with various specification versions.
The author/maintainer is Nick Maynard. Fork this project on Github.
Thanks


www.awsiamlogin.com aims at providing easy access to manage and navigate across multiple Amazon Web Services (AWS) Accounts and bookmarking. AWS strongly recommends usage of IAM Access and the structure of the AWS IAM Login Portal or with AWS Alias; for which the URL isn’t rememberable (easily) thus leaning towards the usage of root account.
Today DevOps and Cloud Architects have the need to manage across multiple AWS accounts and adding more to the problem of remembering the AWS IAM Portal.
The feature set include


Prescription submissions Teds pharmacy Logout
{{totalUnpaidItemsCount}}
unpaid items
Why are these unpaid?
{% if rejectedItemsCount==0 %}
{% endif %} {% if rejectedItemsCount>0 %}
{% endif %} {% if rejectedItemsCount==0 %} {% endif %} {% if rejectedItemsCount>0 %} {% endif %} {{rejectedItemsCount}} items Missing information {% if rejectedItemsCount>0 %} Add information {% endif %}
{{pendingItemsCount}} items Information received and being reviewed
31/12/2016
next payment
513
items
This payment includes
Unpaid items which are corrected and approved by 19/12/2016 can be added to this payment


--- layout: post title: Civil War date: '2016-04-05T04:33:08+02:00' categories: - Sketches - Sketchbooks picture_url: https://film-Storyboards.tumblr.com/post/142286973641 ---


The food manufacturing business in South Germany has a strong labour union. MNI has resisted the formation of labour unions across other parts of their business in the US. How should they respond
- German facility - Fixed Costs 60%
- US facility - Fixed Costs 40%
Basic Points
- Anti-Union: Labour Unions reduce flexibility and competitiveness of an organization
- Pro-Union: Recognize that the context of a Labour Union in Germany is different from US. In many senses Labor Union practices have underpinned the sustainable growth of the Germany economy. In both countries Labour Unions exist to protect the rights of the working classes to fair wages and healthcare.
Advanced Comments
- Cost Structure: German facility has higher fixed costs and is probably more automated. In turn, this means that they require fewer employees who are probably highly educated engineers and technicians. These employees expect to be paid higher wages than their US equivalents.
- European Stakeholder Economy: In Europe Labour Unions play a different role than in the US. Behaviour stems from a belief in the "Stakeholder Economy" in which the role of the enterprise is to look after employees and shareholders alike. In Germany the model is basically as follows: general labour agreements are made at the national level by national unions (e.g. IG Metall) and national employer associations (e.g. Gesamtmetall). Local plants and firms then meet with works councils to adjust these national agreements to local circumstances. Works council representatives may also be appointed to the Board of Directors. In general, the relationship is less adversarial than an equivalent organization in the US. In fact works councils have been credited for improving and systematizing communication channels within Germany companies. This may be one factor that explains the sustained growth and success of the Germany economy.
- Low Cost Alternatives: If MNI wants to stick with their existing approach using a low level of automation and a high portion of low skilled workers then they might be better to consider setting up a production facility in Eastern Europe rather than Germany.
Conclusion
- MNI should support the labour union in Germany giving them a seat on the Board of Directors and approaching the relationship in a positive manner. Otherwise they would risk destroying much of the value in the human capital of the business they have acquired.


Jul 27, 2021
1 min read
Walls have erected and cities built.
People have a habit to ritualize this wealth.
A war without a shot fired until the end was written.
Quarantine through cast will fix the set.
Walking the line with emotiv propulsion spins me around
Splitting two naturals for two perfect partners
Grows a beautiful aliance
Afterthought what if infects with doubt
who am I?
Where am I going?
And what do I know?
Here we are, what do we do?
Walk as though you are following you shadow because you have been here before.
- Henock
Sharing is caring!


This is data from the Terry Morgan lab at OHSU. Tandem mass tags were used to label human vulvar vestibulitis tissue samples. There were 4 control samples, 8 primary vestibulitis, and 2 secondary vestibulitis. The 14 samples were distributed across two TMT 10-plex channels. A master pool of all samples was created, and duplicate channels of the pooled standard were included in each 10-plex run. Because we had two extra channels out of the 16 available, the 41 and 42 control samples were labeled twice and split between the plexes.
The Internal Reference Scaling method was used to adjust each TMT experiment onto a common reporter ion scale. The data was first acquired on a first generation Thermo Fusion Tribrid instrument using the SPS MS3 method in August 2015. The frozen samples were re-ran on a Q-Exactive HF in May 2017. This notebook will look at the QE MS2 data. An on-line high pH separation was used to fractionate the samples into 17 first dimensions. A low pH 2-hour gradient was used for the second dimension. Data analysis used the open source PAW pipeline to confidently identify proteins with high sensitivity and aggregate reporter ion signals.
Statistical analysis used the Bioconductor package edgeR in a Jupyter notebook running an R kernel. The PAW pipeline produces manageable, informative summary tables. The PAW results and statistical testing results were integrated into a final Excel spreadsheet.
The data has not yet been published and is not publicly available.
Thompson, A., Schäfer, J., Kuhn, K., Kienle, S., Schwarz, J., Schmidt, G., Neumann, T. and Hamon, C., 2003. Tandem mass tags: a novel quantification strategy for comparative analysis of complex protein mixtures by MS/MS. Analytical chemistry, 75(8), pp.1895-1904.
Wilmarth, P.A., Riviere, M.A. and David, L.L., 2009. Techniques for accurate protein identification in shotgun proteomic studies of human, mouse, bovine, and chicken lenses. Journal of ocular biology, diseases, and informatics, 2(4), pp.223-234.
Plubell, D.L., Wilmarth, P.A., Zhao, Y., Fenton, A.M., Minnier, J., Reddy, A.P., Klimek, J., Yang, X., David, L.L. and Pamir, N., 2017. Extended multiplexing of tandem mass tags (TMT) labeling reveals age and high fat diet specific proteome changes in mouse epididymal adipose tissue. Molecular & Cellular Proteomics, 16(5), pp.873-890.
Gentleman, R.C., Carey, V.J., Bates, D.M., Bolstad, B., Dettling, M., Dudoit, S., Ellis, B., Gautier, L., Ge, Y., Gentry, J. and Hornik, K., 2004. Bioconductor: open software development for computational biology and bioinformatics. Genome biology, 5(10), p.R80.
Robinson, M.D., McCarthy, D.J. and Smyth, G.K., 2010. edgeR: a Bioconductor package for differential expression analysis of digital gene expression data. Bioinformatics, 26(1), pp.139-140.
# library imports
library(tidyverse)
library(scales)
library(limma)
library(edgeR)
library(psych)
# ================== TMM normalization from DGEList object =====================
apply_tmm_factors <- function(y, color = NULL, plot = TRUE) {
# computes the tmm normalized data from the DGEList object
# y - DGEList object
# returns a dataframe with normalized intensities
# compute and print "Sample loading" normalization factors
lib_facs <- mean(y$samples$lib.size) / y$samples$lib.size
cat("\nLibrary size factors:\n",
sprintf("%-5s -> %f\n", colnames(y$counts), lib_facs))
# compute and print TMM normalization factors
tmm_facs <- 1/y$samples$norm.factors
cat("\nTrimmed mean of M-values (TMM) factors:\n",
sprintf("%-5s -> %f\n", colnames(y$counts), tmm_facs))
# compute and print the final correction factors
norm_facs <- lib_facs * tmm_facs
cat("\nCombined (lib size and TMM) normalization factors:\n",
sprintf("%-5s -> %f\n", colnames(y$counts), norm_facs))
# compute the normalized data as a new data frame
tmt_tmm <- as.data.frame(sweep(y$counts, 2, norm_facs, FUN = "*"))
colnames(tmt_tmm) <- str_c(colnames(y$counts), "_tmm")
# visualize results and return data frame
if(plot == TRUE) {
boxplot(log10(tmt_tmm), col = color, notch = TRUE, main = "TMM Normalized data")
}
tmt_tmm
}
# ============== CV function ===================================================
CV <- function(df) {
# Computes CVs of data frame rows
# df - data frame,
# returns vector of CVs (%)
ave <- rowMeans(df) # compute averages
sd <- apply(df, 1, sd) # compute standard deviations
cv <- 100 * sd / ave # compute CVs in percent (last thing gets returned)
}
# =========== Boxplot with median label ========================================
labeled_boxplot <- function(df, ylim, title) {
# Makes a box plot with the median value labeled
# df - data frame with data to compute CVs of
# ylim - upper limit for y-axis
# title - plot title
cv = CV(df)
boxplot(cv, ylim = c(0, ylim), notch = TRUE, main = title)
text(x = 0.65, y = boxplot.stats(cv)$stats[3],
labels = round(boxplot.stats(cv)$stats[3], 1))
}
# ================= reformat edgeR test results ================================
collect_results <- function(df, tt, x, xlab, y, ylab) {
# Computes new columns and extracts some columns to make results frame
# df - data in data.frame
# tt - top tags table from edgeR test
# x - columns for first condition
# xlab - label for x
# y - columns for second condition
# ylab - label for y
# returns a new dataframe
# condition average vectors
ave_x <- rowMeans(df[x])
ave_y <- rowMeans(df[y])
# FC, direction, candidates
fc <- ifelse(ave_y > ave_x, (ave_y / ave_x), (-1 * ave_x / ave_y))
direction <- ifelse(ave_y > ave_x, "up", "down")
candidate <- cut(tt$FDR, breaks = c(-Inf, 0.01, 0.05, 0.10, 1.0),
labels = c("high", "med", "low", "no"))
# make data frame
temp <- cbind(df[c(x, y)], data.frame(logFC = tt$logFC, FC = fc,
PValue = tt$PValue, FDR = tt$FDR,
ave_x = ave_x, ave_y = ave_y,
direction = direction, candidate = candidate,
Acc = tt$genes))
# fix column headers for averages
names(temp)[names(temp) %in% c("ave_x", "ave_y")] <- str_c("ave_", c(xlab, ylab))
temp # return the data frame
}
# =============== p-value plots ================================================
pvalue_plots <- function(results, ylim, title) {
# Makes p-value distribution plots
# results - results data frame
# ylim - ymax for expanded view
# title - plot title
p_plot <- ggplot(results, aes(PValue)) +
geom_histogram(bins = 100, fill = "white", color = "black") +
geom_hline(yintercept = mean(hist(results$PValue, breaks = 100,
plot = FALSE)$counts[26:100]))
# we will need an expanded plot
p1 <- p_plot + ggtitle(str_c(title, " p-value distribution"))
p2 <- p_plot + coord_cartesian(xlim = c(0, 1.0), ylim = c(0, ylim)) + ggtitle("p-values expanded")
grid.arrange(p1, p2, nrow = 2) # from gridExtra package
}
# ============= log2 fold-change distributions =================================
log2FC_plots <- function(results, range, title) {
# Makes faceted log2FC plots by candidate
# results - results data frame
# range - plus/minus log2 x-axis limits
# title - plot title
ggplot(results, aes(x = logFC, fill = candidate)) +
geom_histogram(binwidth=0.1, color = "black") +
facet_wrap(~candidate) +
ggtitle(title) +
coord_cartesian(xlim = c(-range, range))
}
# ========== Setup for MA and volcano plots ====================================
transform <- function(results, x, y) {
# Make data frame with some transformed columns
# results - results data frame
# x - columns for x condition
# y - columns for y condition
# return new data frame
df <- data.frame(log10((results[x] + results[y])/2),
log2(results[y] / results[x]),
results$candidate,
-log10(results$FDR))
colnames(df) <- c("A", "M", "candidate", "P")
df # return the data frame
}
# ========== MA plots using ggplot =============================================
MA_plots <- function(results, x, y, title) {
# makes MA-plot DE candidate ggplots
# results - data frame with edgeR results and some condition average columns
# x - string for x-axis column
# y - string for y-axis column
# title - title string to use in plots
# returns a list of plots
# uses transformed data
temp <- transform(results, x, y)
# 2-fold change lines
ma_lines <- list(geom_hline(yintercept = 0.0, color = "black"),
geom_hline(yintercept = 1.0, color = "black", linetype = "dotted"),
geom_hline(yintercept = -1.0, color = "black", linetype = "dotted"))
# make main MA plot
ma <- ggplot(temp, aes(x = A, y = M)) +
geom_point(aes(color = candidate, shape = candidate)) +
scale_y_continuous(paste0("logFC (", y, "/", x, ")")) +
scale_x_continuous("Ave_intensity") +
ggtitle(title) +
ma_lines
# make separate MA plots
ma_facet <- ggplot(temp, aes(x = A, y = M)) +
geom_point(aes(color = candidate, shape = candidate)) +
scale_y_continuous(paste0("log2 FC (", y, "/", x, ")")) +
scale_x_continuous("log10 Ave_intensity") +
ma_lines +
facet_wrap(~ candidate) +
ggtitle(str_c(title, " (separated)"))
# make the plots visible
print(ma)
print(ma_facet)
}
# ========== Scatter plots using ggplot ========================================
scatter_plots <- function(results, x, y, title) {
# makes scatter-plot DE candidate ggplots
# results - data frame with edgeR results and some condition average columns
# x - string for x-axis column
# y - string for y-axis column
# title - title string to use in plots
# returns a list of plots
# 2-fold change lines
scatter_lines <- list(geom_abline(intercept = 0.0, slope = 1.0, color = "black"),
geom_abline(intercept = 0.301, slope = 1.0, color = "black", linetype = "dotted"),
geom_abline(intercept = -0.301, slope = 1.0, color = "black", linetype = "dotted"),
scale_y_log10(),
scale_x_log10())
# make main scatter plot
scatter <- ggplot(results, aes_string(x, y)) +
geom_point(aes(color = candidate, shape = candidate)) +
ggtitle(title) +
scatter_lines
# make separate scatter plots
scatter_facet <- ggplot(results, aes_string(x, y)) +
geom_point(aes(color = candidate, shape = candidate)) +
scatter_lines +
facet_wrap(~ candidate) +
ggtitle(str_c(title, " (separated)"))
# make the plots visible
print(scatter)
print(scatter_facet)
}
# ========== Volcano plots using ggplot ========================================
volcano_plot <- function(results, x, y, title) {
# makes a volcano plot
# results - a data frame with edgeR results
# x - string for the x-axis column
# y - string for y-axis column
# title - plot title string
# uses transformed data
temp <- transform(results, x, y)
# build the plot
ggplot(temp, aes(x = M, y = P)) +
geom_point(aes(color = candidate, shape = candidate)) +
xlab("log2 FC") +
ylab("-log10 FDR") +
ggtitle(str_c(title, " Volcano Plot"))
}
# ============== individual protein expression plots ===========================
# function to extract the identifier part of the accesssion
get_identifier <- function(accession) {
identifier <- str_split(accession, "\\|", simplify = TRUE)
identifier[,3]
"X"
}
set_plot_dimensions <- function(width_choice, height_choice) {
options(repr.plot.width=width_choice, repr.plot.height=height_choice)
}
plot_top_tags <- function(results, nleft, nright, top_tags) {
# results should have data first, then test results (two condition summary table)
# nleft, nright are number of data points in each condition
# top_tags is number of up and number of down top DE candidates to plot
# get top ipregulated
up <- results %>%
filter(logFC >= 0) %>%
arrange(FDR)
up <- up[1:top_tags, ]
# get top down regulated
down <- results %>%
filter(logFC < 0) %>%
arrange(FDR)
down <- down[1:top_tags, ]
# pack them
proteins <- rbind(up, down)
color = c(rep("red", nleft), rep("blue", nright))
for (row_num in 1:nrow(proteins)) {
row <- proteins[row_num, ]
vec <- as.vector(unlist(row[1:(nleft + nright)]))
names(vec) <- colnames(row[1:(nleft + nright)])
title <- str_c(get_identifier(row$Acc), ", int: ", scientific(mean(vec), 2),
", FDR: ", scientific(row$FDR, digits = 3),
", FC: ", round(row$FC, digits = 1))
barplot(vec, col = color, main = title,
cex.main = 1.0, cex.names = 0.7, cex.lab = 0.7)
}
}
The pandas Python script that does the IRS normalization arranges the tab-delimited table so that importing into R is relatively straightforward.
# load the IRS-normalized data and check the table
data_import <- read_tsv("labeled_grouped_protein_summary_TMT_9_IRS_normalized.txt", guess_max = 5632)
# "Filter" column flags contams and decoys
# "Missing" column flags proteins without reporter ion intensities (full sets missing)
# the table from pandas is sorted so the rows we want come first
data_all <- filter(data_import, is.na(Filter), is.na(Missing))
accessions <- data_all$Accession # save gene names for edgeR so we can double check that results line up
ncol(data_all)
nrow(data_all)
There are always multiple normalizations in these workflows. We have the same total amount of protein based on protein assays before the labeling reactions. We might have peptide assays after digestion to determine equal amounts of digest to label. In our core, we do a separate "normalization" run where equal volumes of the TMT-labeled reaction mixtures are mixed and analyzed in a single LC run. The total reporter ion signal per channel is used as a proxy for total digest for each sample. We adjust final mixing volumes to try and achieve more equal intensity totals across the sample.
Despite all of those "bench" normalizations, we will still need to do several software normalizations. The intensity totals per channel within each plex (after excluding contaminants) will still not be the same. We first take care of that for each plex. Each TMT plex may have different average total intensities per experiment (instruments vary over time). We can also make those match. These are the gross normalization adjustments. These single factor scalings are designed to get all of the data into the same ballpark so that more sophisticated normalizations can be more safely applied.
The IRS method to correct for pseudo-random MS2 scan selection is necessary to combine data from multiple TMT experiments (plexes). It should be done after sample-loading corrections (and overall instrument level matching between plexes). This gets all of the individual channel measurements over all of the plexes onto the same measurement scale so we can work with the data like we had a single really big TMT kit.
Liu, H., Sadygov, R.G. and Yates, J.R., 2004. A model for random sampling and estimation of relative protein abundance in shotgun proteomics. Analytical chemistry, 76(14), pp.4193-4201.
We adjust actual reporter ion intensities. We do not work with any ratios at any of these critical early normalization steps. Once we have all of the sample measurements adjusted to the same valid measurement scale, different biological conditions (groups) can have compositional changes. Those compositional changes can throw off grand total values (how we mostly do the normalizations). Algorithms like the trimmed mean of M-values are designed to find and correct any compositional differences.
To do good science, we should thoroughly check our data before and after these normalization steps. Visualizations are effective strategies because a picture really is worth a thousand words. The human brain is very good at processing visual patterns. We can look at the starting (RAW) reporter ion intensities before we do any software normalizations.
# see how raw data clusters - we have 11 channels per plex (one unused)
data_raw <- select(data_all, starts_with("TotInt_"))
# see colors by plex: black and blue are Fusion; red and green are QE
colors_all <- c(rep("black", 11), rep("red", 11))
# check the intensity distributions
boxplot(log10(data_raw), col = colors_all, notch = TRUE, main = "RAW Data")
The PAW pipeline assumes 11-plex TMT reagents (6-plex and 10-plex are subsets of 11-plex). We had 10-plex reagents, so the 11th channel in each plex was not used. Get the sample loading (SLNorm) and IRS normalized data (IRSNorm) for the used channels.
data_irs <- select(data_all, contains("IRSNorm"), -contains("unused"))
data_sl <- select(data_all, contains("SLNorm"), -contains("unused"))
# define the 3 groups
control_sl <- select(data_sl, contains("Control"))
primary_sl <- select(data_sl, contains("Primary"))
secondary_sl <- select(data_sl, contains("Secondary"))
control_irs <- select(data_irs, contains("Control"))
primary_irs <- select(data_irs, contains("Primary"))
secondary_irs <- select(data_irs, contains("Secondary"))
pools_before <- select(data_sl, contains("Pool"))
pools_after <- select(data_irs, contains("Pool"))
We had a table with 3650 rows for the original Fusion data. We have 34% more proteins with the faster duty cycle on the QE. The first generation Fusion is a powerful instrument with the tribrid configuration. The newer platforms are more sensitive and faster, however.
We should have the biological groups clustering together. We have Control samples 41 and 42 that are present in both plexes as another sanity check.
# put groups together into a single data frame
tmt_sl <- bind_cols(control_sl, primary_sl, secondary_sl)
tmt_irs <- bind_cols(control_irs, primary_irs, secondary_irs)
control <- 1:6
primary <- 7:14
secondary <- 15:16
# set some colors by condition
colors = c(rep('red', length(control)), rep('blue', length(primary)), rep('green', length(secondary)))
# check clustering before starting analysis
plotMDS(log2(tmt_sl), main = "Before IRS", col = colors)
The SLNorm data has strong left and right separation between the two plexes.
# clustering after IRS
plotMDS(log2(tmt_irs), main = "After IRS", col = colors)
After using the pooled reference channels in each plex for the IRS method, we remove the TMT plex effect and have some separations between the control samples (in red) from the syndrome samples (blue and green). It is always worth mentioning that the data (the reference channels) used to make the adjustments are independent of the actual biological sample data. This reduces any possibilities of confounding the correction factors and the expression changes. It also eliminates any need for carefully balanced allocations of samples by plex, something that can be hard with relatively small numbers of channels per TMT plex.
We also see that the duplicate channels for samples 41 and 42 are somewhat close together after IRS. However, they do not cluster together to the same degree that we saw in the Fusion SPS MS3 data. We should keep this in mind as we compare/contrast the platforms in the rest of this notebook.
We can see the effect of the pseudo-random MS2 sampling in the data before IRS and how effective the IRS method is at correcting that. The upper left scatter plot and lower right scatter plots are within a single plex. The lower left set of 4 scatter plots, with dramatically larger scatter, are channels between plexes.
pairs.panels(log10(pools_before), main = "Standards before IRS")
pairs.panels(log10(pools_after), main = "Standards after IRS")
The pooled reference sample is identical in each of its channels. If our measurements are valid, we should have repeated measurements of the same thing yield nearly identical intensities. We achieve that with the IRS method. The data from the QE's MS2 scans almost looks too good.
Some data normalizations are integral to the IRS procedure. There can still be compositional differences between samples from different biological conditions that IRS would not address. The trimmed mean of M-values normalization in edgeR is designed for these large-scale experiments.
Robinson, M.D. and Oshlack, A., 2010. A scaling normalization method for differential expression analysis of RNA-seq data. Genome biology, 11(3), p.R25.
We load the data into edgeR data structures and called the calcNormFactors
function to perform library size and the trimmed mean of M-values (TMM) normalization. We will double check if the TMM normalization changed the clustering.
We need to use the edgeR normalization factors to produce the TMM normalized data that the statistical testing will be working with. EdgeR uses the normalization factors in its statistical modeling but does not output the normalized intensities. We have to compute the normalized intensities with the apply_tmm_factors
function.
We kept the duplicate channels for samples 41 and 42 in the data for the above sanity checks. We need to remove those extra technical-like replicates or they will artificially reduce the control group variance and throw off the testing p-values. We will take sample 41 from the first plex and sample 42 from the second plex.
# drop the extra control channels
control_sl <- control_sl %>% select(., -contains("42_1")) %>% select(., -contains("41_2"))
control_irs <- control_irs %>% select(., -contains("42_1")) %>% select(., -contains("41_2"))
# put groups together into a single data frame
tmt_sl <- bind_cols(control_sl, primary_sl, secondary_sl)
tmt_irs <- bind_cols(control_irs, primary_irs, secondary_irs)
control <- 1:4
primary <- 5:12
secondary <- 13:14
# set some colors by condition
colors = c(rep('red', length(control)), rep('blue', length(primary)), rep('green', length(secondary)))
# get the biological sample data into a DGEList object
group = c(rep("C", length(control)), rep("P", length(primary)), rep("S", length(secondary)))
y <- DGEList(counts = tmt_irs, group = group, genes = accessions)
# run TMM normalization (also includes a library size factor)
y <- calcNormFactors(y)
tmt_tmm <- apply_tmm_factors(y, color = colors, plot = FALSE)
# check the clustering
plotMDS(y, col = colors, main = "all samples after TMM")
The IRS method kind of takes care of the library size type of normalizations. We could still have compositional differences between sample groups that the TMM factors would correct. Most TMM factors are not very different from 1.0 (smallest is 0.92 and largest is 1.06), so we do not seem to have any large compositional differences.
The box plots below are very similar across samples. TMM usually gets the medians (box centers) aligned pretty well. We also have the sizes of the boxes being very similar sample-to-sample.
Box plots for well-normalized data should be similar in size and the medians should align with each other. There can be problems with the data that may not be apparent with boxplots (some data distortions can average out and not appear different with boxplots). We will use ggplot2 this time and flip the graph on its side, so we can read the labels easier. We need tidy (long form) data for ggplot.
# need to make tidy data format
long_results <- gather(tmt_tmm, key = "sample", value = "intensity") %>%
mutate(log_int = log10(intensity)) %>%
extract(sample, into = 'group', "IRSNorm_(.*)-", remove = FALSE)
# head(long_results)
# plot the boxplots
ggplot(long_results, aes(x = sample, y = log_int, fill = group)) +
geom_boxplot(notch = TRUE) +
coord_flip() +
ggtitle("Intensity distribution of each channel")
The distributions of Coefficients of Variation (CVs) are another way to get an idea of how individual proteins are behaving. This is an effective way to assess proper normalization in these experiments. We will compute CV distributions for each of the biological conditions.
We would expect samples within the same biological group to be similar to each other. It follows that when normalization methods are working to remove non-biological sources of variation, we should see median CVs and CV distributions improve after normalization.
# put CVs in data frames to simplify plots and summaries
cv_sl <- data.frame(C.sl = CV(tmt_sl[control]), P.sl = CV(tmt_sl[primary]),
S.sl = CV(tmt_sl[secondary]))
cv_irs <- data.frame(C.irs = CV(tmt_irs[control]), P.irs = CV(tmt_irs[primary]),
S.irs = CV(tmt_irs[secondary]))
cv_tmm <- data.frame(C.tmm = CV(tmt_tmm[control]), P.tmm = CV(tmt_tmm[primary]),
S.tmm = CV(tmt_tmm[secondary]))
# see what the median CV values are
medians <- apply(cv_sl, 2, FUN = median)
print("SLNorm median CVs by condition (%)")
round(medians, 2)
medians <- apply(cv_irs, 2, FUN = median)
print("IRSNorm median CVs by condition (%)")
round(medians, 2)
medians <- apply(cv_tmm, 2, FUN = median)
print("Final median CVs by condition (%)")
round(medians, 2)
We see some significant improvements in the median CVs after IRS compared to the sample total loading adjustments (SLNorm). The TMM step does not change the median CVs much over IRS.
We will likely have some dynamic range compression for the reporter ions in the MS2 scans. The median CVs above are about half of what we had for the original Fusion data (CVs between 13% and 14% after IRS).
# see what the CV distibutions look like
# need long form for ggplot
long_cv_sl <- gather(cv_sl, key = "condition", value = "cv") %>%
extract(condition, into = 'group', "(.*)\\.sl", remove = FALSE)
# traditional boxplots
ggplot(long_cv_sl, aes(x = group, y = cv, fill = group)) +
geom_boxplot(notch = TRUE) +
ggtitle("SL CV distributions")
# density plots
ggplot(long_cv_sl, aes(x = cv, color = group)) +
geom_density() +
coord_cartesian(xlim = c(0, 150)) +
ggtitle("SL CV distributions")
# need long form for ggplot
long_cv_tmm <- gather(cv_tmm, key = "condition", value = "cv") %>%
extract(condition, into = 'group', "(.*)\\.tmm", remove = FALSE)
# traditional boxplots
ggplot(long_cv_tmm, aes(x = group, y = cv, fill = group)) +
geom_boxplot(notch = TRUE) +
ggtitle("Final CV distributions")
# density plots
ggplot(long_cv_tmm, aes(x = cv, color = group)) +
geom_density() +
coord_cartesian(xlim = c(0, 100)) +
ggtitle("Final CV distributions")
We can also look at each biological condition with a multi-panel scatter plot grid and see how similar the replicates are to each other. We can look at the intensities before IRS and after IRS with TMM (final data).
# multi-panel scatter plot grids, SLNorm data
pairs.panels(log10(tmt_sl[control]), lm = TRUE, main = "Controls - SLNorm")
pairs.panels(log10(tmt_sl[primary]), lm = TRUE, main = "Primary - SLNorm")
pairs.panels(log10(tmt_sl[secondary]), lm = TRUE, main = "Secondary - SLNorm")
The rather low-scatter scatter plots within plex are now very distinct from the wide, wedge-shaped plots from channels between plexes.
# multi-panel scatter plot grids, final data
pairs.panels(log10(tmt_tmm[control]), lm = TRUE, main = "Control - final")
pairs.panels(log10(tmt_tmm[primary]), lm = TRUE, main = "Primary - final")
pairs.panels(log10(tmt_tmm[secondary]), lm = TRUE, main = "Secondary - final")
We have considerable variance (large scatter and lower correlation coefficients) between plexes before IRS. That is removed by the IRS method. The QE MS2 data have pretty narrow scatter plots and very high correlation coefficients. This is a little different compared to the SPS MS3 data from the Fusion.
We have loaded data into some edgeR data structures so we could run the TMM normalization function. We have not yet run any of the edgeR functions that do the statistical testing.
One of the more powerful features of edgeR (and limma) is computing variances across larger numbers of genes (proteins) to get more robust variance estimates for small replicate experiments. Here, we have 16 samples across all conditions to use to improve the variance estimates and reduce false positive differential expression (DE) candidates. We have an edgeR estimateDisp
function that does all of this and a visualization function to check the result.
We loaded the IRS data into DGEList
object y
a few cells above and did the normalization step. We need to estimate the dispersion parameters before we can do the actual statistical testing. This only needs to be done once. Each exact test will take two conditions and compare them using the normalization factors and dispersion estimates saved in y
.
# compute dispersions and plot BCV
y <- estimateDisp(y)
plotBCV(y, main = "BCV plot of IRS/TMM normalized data")
We will specify the pair of interest for the exact test in edgeR and use the experiment-wide dispersion. The decideTestsDGE
call will tell us how many up and down regulated candidates we have at an FDR of 0.10. The topTags
call does the Benjamini-Hochberg multiple testing corrections. We save the test results in tt
. We use a handy MA (mean-average) plotting function from limma
to visualize the DE candidates, and then check the p-value distribution.
# the exact test object has columns like fold-change, CPM, and p-values
et <- exactTest(y, pair = c("C", "P"))
# this counts up, down, and unchanged genes (proteins) at 10% FDR
summary(decideTestsDGE(et, p.value = 0.10))
# the topTags function adds the BH FDR values to an exactTest data frame
# make sure we do not change the row order (the sort.by parameter)!
# topTags(et)$table
tt <- topTags(et, n = Inf, sort.by = "none")
# make an MD plot (like MA plot)
plotMD(et, p.value = 0.10)
abline(h = c(-1, 1), col = "black")
# check the p-value distribution
ggplot(tt$table, aes(PValue)) +
geom_histogram(bins = 100, fill = "white", color = "black") +
geom_hline(yintercept = mean(hist(et$table$PValue, breaks = 100,
plot = FALSE)$counts[26:100])) +
ggtitle("Control vs Primary p-value distribution")
The numbers of candidates are pretty large and split between up and down regulation, as can be seen in the MA plot. The p-value distribution has a nice flat distribution of larger p-values (from non-DE candidates) and a large spike at small p-values from true DE candidates. Very few candidates exceed a 2-fold difference.
We had 552 DE candiates for the Fusion and we have 855 here. That is an increase of 55%. We had 34% more quantifiable proteins (4,900 versus 3,650), so we are gaining DE candidates quite a bit faster than we gained proteins.
We will add the statistical testing results (logFC, p-values, and FDR), condition intensity averages, and candidate status to the results
data frame (which has the TMM-normalized data) and also accumulate all of the three comparisons into all_results
.
# get the results summary
results <- collect_results(tmt_tmm, tt$table, control, "C", primary, "P")
# make column names unique by adding comparison (for the accumulated frame)
results_temp <- results
colnames(results_temp) <- str_c(colnames(results), "_CvsP")
# accumulate the testing results
all_results <- results_temp
Log2 fold-change distribution plots are fairly common in proteomics. We can make those separately for the different levels of significant categories from the edgeR test results (no > 0.10 > low > 0.05 > med > 0.01 > high).
# see how many candidates by category
results %>% count(candidate)
# plot log2 fold-changes by category
ggplot(results, aes(x = logFC, fill = candidate)) +
geom_histogram(binwidth=0.1, color = "black") +
coord_cartesian(xlim = c(-3, 3)) +
ggtitle("C vs P logFC distributions by candidate")
# plot log2 fold-changes by category
ggplot(results, aes(x = logFC, fill = candidate)) +
geom_histogram(binwidth=0.1, color = "black") +
facet_wrap(~candidate) +
coord_cartesian(xlim = c(-3, 3)) +
ggtitle("C vs P logFC distributions by candidate")
We have many comparisons to visualize, so we will use some of the functions at the top of the notebook to generate a series of plots. We will make: an MA plot with candidates highlighted by color, faceted MA plots separated by candidate status, a scatter plot with candidates highlighted by color, faceted scatter plots separated by candidate status, and a volcano plot with candidates highlighted by color. The solid black lines in the MA and scatter plots are the 1-to-1 lines; the dotted lines are 2-fold change lines.
# make MA plots
MA_plots(results, "ave_C", "ave_P", "Control vs Primary")
# make scatter plots
scatter_plots(results, "ave_C", "ave_P", "Control vs Primary")
# make a volcano plot
volcano_plot(results, "ave_C", "ave_P", "Control vs Primary")
We have more candidates associated with over-expression in the primary samples, and the fold-changes seem larger. My eye sees less clear separation between DE candidates and non-candidates for the more compressed QE data. My internal scale of what constitutes a convincing expression difference seems to be calibrated differently than statistical models of significance.
We will look at some protein in more detail. We will filter for the 25 most statistically significant over and under expressed proteins. The plots are colored by condition. The labels at the top of each plot have the identifier, the average reporter ion intensity, the B-H corrected p-value, and the fold change.
Note: this data has not yet been published (I know, why not?) so I have hidden the protein accessions. Sorry!
top_N <- 25
set_plot_dimensions(6, 3.5)
plot_top_tags(results, length(control), length(primary), top_N)
set_plot_dimensions(7, 7)
The plots demonstrate that there are different ways for expression patterns to hit the same p-values. Some of the plots look convincing to me and others do not. I think the top DE candidates from the SPS MS3 Fusion data had clearer (i.e. larger) differences in means.
We will repeat similar analysis steps to compare the 4 control samples to the 2 secondary samples.
# the exact test object has columns like fold-change, CPM, and p-values
et <- exactTest(y, pair = c("C", "S"))
# this counts up, down, and unchanged genes (proteins) at 10% FDR
summary(decideTestsDGE(et, p.value = 0.10))
# the topTags function adds the BH FDR values to an exactTest data frame
# make sure we do not change the row order (the sort.by parameter)!
# topTags(et)$table
tt <- topTags(et, n = Inf, sort.by = "none")
# make an MD plot (like MA plot)
plotMD(et, p.value = 0.10)
abline(h = c(-1, 1), col = "black") # 2-fold change lines
# check the p-value distribution
ggplot(tt$table, aes(PValue)) +
geom_histogram(bins = 100, fill = "white", color = "black") +
geom_hline(yintercept = mean(hist(et$table$PValue, breaks = 100,
plot = FALSE)$counts[26:100])) +
ggtitle("C vs S p-value distribution")
We have reduced numbers of candidates and the data are a bit noisier. The p-value distribution has a flat distribution of larger p-values (from non-DE candidates) and a spike at small p-values from true DE candidates. We again have some candidate bias towards over-expression in the secondary samples.
We have 57 DE candidates here and we had 54 on the Fusion. That is less than 6% relative gain from 34% more proteins. The interplay between variance estimates and the magnitude of the difference in means is not so simple or easy to predict.
We will add the statistical testing results (logFC, p-values, and FDR), condition intensity averages, and candidate status to the results
data frame (which has the TMM-normalized data) and also accumulate all of the three comparisons into all_results
.
# get the results summary
results <- collect_results(tmt_tmm, tt$table, control, "C", secondary, "S")
# make column names unique by adding comparison
results_temp <- results
colnames(results_temp) <- str_c(colnames(results), "_CvsS")
# accumulate the testing results
all_results <- cbind(all_results, results_temp)
# see how many candidates by category
results %>% count(candidate)
# plot log2 fold-changes by category
ggplot(results, aes(x = logFC, fill = candidate)) +
geom_histogram(binwidth=0.1, color = "black") +
facet_wrap(~candidate) +
coord_cartesian(xlim = c(-4, 4)) +
ggtitle("C vs S logFC distributions by candidate")
# make MA plots
MA_plots(results, "ave_C", "ave_S", "Control vs Secondary")
# make scatter plots
scatter_plots(results, "ave_C", "ave_S", "Control vs Secondary")
# make a volcano plot
volcano_plot(results, "ave_C", "ave_S", "Control vs Secondary")
top_N <- 10
set_plot_dimensions(6, 3.5)
plot_top_tags(results, length(control), length(secondary), top_N)
set_plot_dimensions(7, 7)
# the exact test object has columns like fold-change, CPM, and p-values
et <- exactTest(y, pair = c("P", "S"))
# this counts up, down, and unchanged genes (proteins) at 10% FDR
summary(decideTestsDGE(et, p.value = 0.10))
# the topTags function adds the BH FDR values to an exactTest data frame
# make sure we do not change the row order (the sort.by parameter)!
# topTags(et)$table
tt <- topTags(et, n = Inf, sort.by = "none")
# make an MD plot (like MA plot)
plotMD(et, p.value = 0.10)
abline(h = c(-1, 1), col = "black")
# check the p-value distribution
ggplot(tt$table, aes(PValue)) +
geom_histogram(bins = 100, fill = "white", color = "black") +
geom_hline(yintercept = mean(hist(et$table$PValue, breaks = 100,
plot = FALSE)$counts[26:100])) +
ggtitle("P vs S p-value distribution")
There are no DE candidates and the p-value distribution is flat without any low p-value spike. We only had 4 DE candidates for the Fusion, so the comparisons are quite similar between instruments at some higher qualitative level.
We will add the statistical testing results (logFC, p-values, and FDR), condition intensity averages, and candidate status to the results
data frame (which has the TMM-normalized data) and also accumulate all of the three comparisons into all_results
.
# get the results summary
results <- collect_results(tmt_tmm, tt$table, primary, "P", secondary, "S")
# make column names unique by adding comparison
results_temp <- results
colnames(results_temp) <- str_c(colnames(results), "_PvsS")
# accumulate the testing results
all_results <- cbind(all_results, results_temp)
# see how many candidates by category
results %>% count(candidate)
# plot log2 fold-changes by category
ggplot(results, aes(x = logFC, fill = candidate)) +
geom_histogram(binwidth=0.1, color = "black") +
facet_wrap(~candidate) +
coord_cartesian(xlim = c(-3, 3)) +
ggtitle("P vs S logFC distributions by candidate")
# make MA plots
MA_plots(results, "ave_P", "ave_S", "Primary vs Secondary")
# make scatter plots
scatter_plots(results, "ave_P", "ave_S", "Primary vs Secondary")
# make a volcano plot
volcano_plot(results, "ave_P", "ave_S", "Primary vs Secondary")
There are only two secondary samples, so it is hard to know if the lack of DE candidates has much real significance.
We demonstrated that the normalizations worked and that the general data quality was good. We had reasonable number of samples in tow of the groups (controls and primary). The two samples for the third group limit the comparisons.
The general characteristics of the Fusion and QE data are quite similar. If this notebook and the Fusion notebook are scrolled side-by-side, most of the data views are qualitatively similar. We have more total proteins quantified with the QE. However, the dynamic range and fold changes are different (reduced) for MS2 data compared to the cleaner MS3 data from the Tribrid. The extra round of isolation and reduced signal probably has some effect on the quality of the Fusion data. Newer, more sensitive Tribrids should generate improved data compared to the first-generation Fusion.
My gut feeling is that the SPS MS3 data feels like better (more believable) measurements. I find the increased dynamic range and accuracy in expression measurements more reassuring.
We will save the testing results table for integration with the proteomics results and log the session.
all_results
frame to TSV file¶write.table(all_results, "QE_results.txt", sep = "\t",
row.names = FALSE, na = " ")
sessionInfo()


|
Keraflow
Deep Learning for Python.
|
An objective function is used to measure how bad (or good) the model is. Concretely, objective functions measures how "far" (or "close") between the model's output and the gold answer. Based on the objective function, the model adjusts its parameters to minimize (or maximize) the score returned by the objective function. Usually, we use the name "loss function" when it is to be minimized.
Model's fit function requires one (or more, for multi-output models) loss function for the loss
argument so that the model can minimize it. Additionally, you could monitor one additional objective function value for each output channel by the metric
argument. Concretely:
Note that you must provide one objective function for each output channel, while you could skip some (or all) output channels for metric
. Also note that the key to refer an output channel is bound to the name of the outputting layer of that channel.
Note that mse
stands for squared_error
and acc
stands for acuracy
. Keraflow uses alias for some build-in objective functions (see below). You could either use the full name or the alias name. Alternatively, You can also pass a Theano/TensorFlow function to the loss
argument:
Note that the function must take two arguments:
y_true
: True labels. 2D (or more) Theano/TensorFlow tensory_pred
: Theano/TensorFlow tensor of the same shape as y_true
.The first dimension of the input tensor is the sample dimension. The function should not average over samples since it is done by Keraflow later. Therefore, the function must return an 2D (or more) tensor with the first dimension the sample dimension.
In addition to dict, you could also pass a list to loss
& metric
:
You could only specify metrics for partial output channels. For the dict method, just specify the target output names. For the list method, we use the first come first serve strategy, i.e. ["acc"]
will only specify accuracy metric for output1
.
m*
, m
stands for mean (over sample points). As said, Keraflow objective function does not average over sample points, so the name of the function does not contain mean
. However, to follow machine learning convention, we still provide alias starting with m
.


{%extends 'base.html' %} {% block content %} {{block.super}}
Welcome to Galleria A photo speak a 1000 words, that explains my wealth.
A photo speak a 1000 words, that explains my wealth.
{{photo_item.description}}
Category : {{photo_item.category}}
Location : {{photo_item.location}}
Uploaded by {{photo_item.user}} on {{photo_item.pub_date}}s


This provides a factory for the java.util.concurrent.locks.Lock interface, as well as a template that ensures locks are safely unlocked.


Add React in On minute
This page demonstrates using React with no build tooling
React is loaded as a script tag.


Self awareness is a focused reflection on how emotional factors can benefit your well being in the present moment and beyond. Mindfulness is purposely paying attention in a focused way and not judging or reflecting in any way. Self awareness and mindfulness have a close relationship because they both require attention, but one big difference is the reflection focus.
I tried the body scan for the back. My experience was such that when I paid attention to my upper back, it made me think about pushing out my chest and have a standing up straight posture. When my attention was on my middle back, this brought focus on tightening my stomach and when my attention was on lower back, this made me tighten my thighs. I felt focused and relaxed during the body scan when I closed my eyes.
I also tried the journal for things that give me pleasure and my strengths are. I had planned what I wanted to write about, before the 2 minutes and during the 2 minutes I got most of it down. I may of felt rushed in writing it all in the 2 minutes, but I got a sense of satisfaction from the good qualities about myself that I was writing down.
Emotions are what you feel at the time and with enough mindfulness practice, you can eventually see emotions as a physiological sensation in the body. An example would be if you feel angry you could feel pain in your shoulders, as if they had been worked out at the gymn. When you are sad, it is the emotion inside your body that is sad, not yourself. If you can control your thoughts and emotions with your mind and your body, then you can increase your sense of well-being.


DIABALLIK
Copyright (c) 2002 Philippe Lefrançois
This game is played on the following 7x7 square board:
- TURNS - At each turn, each player can do the following things (with no specific order):
- Orthogonally move a friendly soldier into an orthogonally adjacent empty cell.
- The player may execute another optional movement with this soldier or with another one (also to an orthogonally adjacent empty cell).
- Optionally, swap the King with a soldier provided that they are in the same (diagonal or horizontal but not vertical) line and separated by empty cells or cells with friendly soldiers.
- The King cannot move by any other means.
- GOAL - Wins the player that places his King into the last row.
In the player's turn, there are three possible actions and any order is possible. He may move, swap and move; or swap, move and move; or just move and swap... Since this is a fast game, player's may execute several games defining a number of wins to decide the match.
If one player simply tries to maintain his own army initial positions, it may be difficult for the adversary to win the game. Considering that, Philippe has a 'anti-play' rule: If a player makes a line which can not be passed, the other player can win if three pieces of him are in contact with this continuous line.
An example Green's turn. Green can win by executing the following sequence: 1) move b6 to c6, 2) move c6 to c7, 3) swap teh King with c7.
Check more information about this game here at the author's website.
[Dec, 2009] Check this Java application to play Diaballik against an AI programmed by Raphaël Couturier.


{% extends "skeleton/_root.html" %} {%hyde title: Test Page amazement: Wow. Am I seeing this on the page! created: 2009-02-17 21:22:23 %} {% block all %}
{{page.amazement}}
Amazed: {{page.created}}


TIFFDUMP
Section: User Commands (1)
Updated: October 15, 1995
Index
Return to Main Contents
NAME
tiffdump - print verbatim information about
TIFF
files
SYNOPSIS
tiffdump
[
options
]
name ...
DESCRIPTION
tiffdump
displays directory information from files created according
to the Tag Image File Format, Revision 6.0.
The header of each
TIFF
file (magic number, version, and first directory offset)
is displayed, followed by the tag contents of each directory in the file.
For each tag, the name, datatype, count, and value(s) is displayed.
When the symbolic name for a tag or datatype is known, the symbolic
name is displayed followed by it's numeric (decimal) value.
Tag values are displayed enclosed in ``<>'' characters immediately
preceded by the value of the count field.
For example, an
ImageWidth
tag might be displayed as ``ImageWidth (256) SHORT (3) 1<800>''.
tiffdump
is particularly useful for investigating the contents of
TIFF
files that
libtiff
does not understand.
OPTIONS
- -h
-
Force numeric data to be printed in hexadecimal rather than the
default decimal.
- -o
-
Dump the contents of the
IFD
at the a particular file offset.
The file offset may be specified using the usual C-style syntax;
i.e. a leading ``0x'' for hexadecimal and a leading ``0'' for octal.
SEE ALSO
tiffinfo(1),
libtiff(3)
Index
- NAME
-
- SYNOPSIS
-
- DESCRIPTION
-
- OPTIONS
-
- SEE ALSO
-
This document was created by
man2html,
using the manual pages.
Time: 01:31:48 GMT, November 23, 1999


lucee.Component swagger-sdk.OpenAPI.Document
Copyright Ortus Solutions, Corp, All rights reserved www.ortussolutions.com --- Open API Document Object
| Property Summary | ||||
|---|---|---|---|---|
| type | property | default | serializable | required |
any
|
Document
|
true
|
false
|
|
any
|
jLoader
|
true
|
false
|
|
any
|
Wirebox
|
true
|
false
|
|
any
|
XPath
|
true
|
false
|
| Constructor Summary | |
|---|---|
|
init(struct Doc, string XPath='')
Constructor. |
| Method Summary | |
|---|---|
any
|
asJSON()
Convenience method to return a JSON representation of the normalized document. |
any
|
asStruct()
Convenience method to return a flattened struct of the Document instance. |
any
|
asYAML()
Convenience method to return a YAML string of the normalized document. |
private string
|
convertToYAML()
Converts the entity doc to a YAML string. |
string
|
getDocument()
|
string
|
getJLoader()
|
any
|
getNormalizedDocument([any APIDoc='[runtime expression]'])
Normalizes the document recursively to provide a flattened representation. |
string
|
getWirebox()
|
string
|
getXPath()
|
any
|
locate([string key])
Helper function to locate deeply nested document items. |
any
|
setDocument(any Document)
|
any
|
setJLoader(any jLoader)
|
private void
|
setResourceIds(struct resourceDoc, [string hashPrefix=''])
Sets the resourceId extension of a document path. |
any
|
setWirebox(any Wirebox)
|
any
|
setXPath(any XPath)
|
private any
|
throwForeignObjectTypeException(any UnKnownObject)
Throws a foreign object type exception if detected when normalizing a document. |
any
|
xPath(string XPath)
Convenience methot for setting the XPath of the Document. |
any
|
zoomToXPath()
Zooms this Document instance to the XPath. |
| Methods inherited from class lucee.Component |
|---|
| None |
| Constructor Detail |
|---|
Constructor
Doc
XPath
| Property Detail |
|---|
access
- publicrequired
- falsereturntype
- anyserializable
- trueaccess
- publicrequired
- falsereturntype
- anyinject
- loader@cbjavaloaderserializable
- trueaccess
- publicrequired
- falsereturntype
- anyinject
- wireboxserializable
- trueaccess
- publicrequired
- falsereturntype
- anyserializable
- true| Method Detail |
|---|
Convenience method to return a JSON representation of the normalized document
Convenience method to return a flattened struct of the Document instance
Convenience method to return a YAML string of the normalized document
Converts the entity doc to a YAML string
Normalizes the document recursively to provide a flattened representation
APIDoc
Helper function to locate deeply nested document items
key
Document
jLoader
Sets the resourceId extension of a document path
resourceDoc
hashPrefix
Wirebox
XPath
Throws a foreign object type exception if detected when normalizing a document
UnKnownObject
Convenience methot for setting the XPath of the Document
XPath
Zooms this Document instance to the XPath


You can use the PackageManager component of PixieDust to install anduninstall maven packages into your notebook kernel without editingconfiguration files. This component is essential when you runnotebooks from a hosted cloud environment and do not have access to the configuration files.
You can use this component in the following ways:
Install a spark package from spark-packages.org.
Install from maven search repository.
Install a jar file directly from an addressable location.
Go to spark-packages.org , and search for your package.
Click the link for your package and locate the code to run the package in spark-shell, pyspark, or spark-submit. For example, you would retrieve the following line:
> $SPARK_HOME/bin/spark-shell --packages graphframes:graphframes:0.1.0-spark1.6
Copy the maven ID of the package. A maven ID includes a group ID,artifact ID, and version number, each separated by a colon (:). Inthe previous example, the maven ID appears after the packages, suchas graphframes:graphframes:0.1.0-spark1.6 .
From a Python notebook, enter the following command:
import pixiedustpixiedust.installPackage("graphframes:graphframes:0.1.0-spark1.6")
To fetch the latest release, specify 0 as the version. The PixieDustpackageManager fetches the latest release in the following example.
import pixiedustpixiedust.installPackage("graphframes:graphframes:0")
After you successfully issue the import command, the following resultsdisplay:
Downloading artifact graphframes:graphframes:0.1.0-spark1.6Downloaded 326112 of 326112 bytes (100.00%)Downloaded artifact graphframes:graphframes:0.1.0-spark1.6 to /Users/dtaieb/data/libs/graphframes-0.1.0-spark1.6.jarArtifact downloaded successfully graphframes:graphframes:0.1.0-spark1.6>>>Please restart Kernel to complete installation of the new packageSuccessfully added artifact graphframes:graphframes:0.1.0-spark1.6
Notice the line that instructs you to restart the kernel to completeinstallation of the new package. This is required only the first time.Restart the kernel by using the Kernel/Restart menu. After thekernel is restarted, the library is added to the classpath and can beused from your Python notebook.
Note
Some libraries, such as GraphFrames include a python module within it. PixieDust automatically adds the python file into the SparkContext. However, you must explicitly call pixiedust.installPackage at the beginning of every kernel session so that the python modules are added to the SparkContext.
Go to the maven search site, search.maven.org , and look for the package of your choice, like org.apache.commons . In the results page, open the link of the component you want, like commons-proxy . You get the group ID, artifact ID, and version number to use with the pixiedust.installPackage API.
By default, PixieDust automatically looks for the following 2 maven repositories: http://repo1.maven.org/maven2 and http://dl.bintray.com/spark-packages/maven . If you use a custom maven repository, you can specify it by using the following base keyword argument:
import pixiedustpixiedust.installPackage("groupId:artifactId:0", base="<<url to my custom maven repo>>"
To install a jar file that is not packaged in a maven repository, provide the URL to the jar file. PixieDust will then bypass the maven look up and directly download the jar file from the specified location:
import pixiedustpixiedust.installPackage("https://github.com/ibm-cds-labs/spark.samples/raw/master/dist/streaming-twitter-assembly-1.6.jar")
You can uninstall a package by using the following command:
import pixiedustpixiedust.uninstallPackage("<<mypackage>>")
You can also list all the packages installed on your system:
import pixiedustpixiedust.printAllPackages()


EUR/USD loses momentum just ahead of 1.1100
by Pablo Piovano- EUR/USD moves higher to the vicinity of the 1.1100 handle.
- US Philly Fed index came in above estimates in November.
- EC’s Consumer Confidence next on the docket.
EUR/USD keeps the firm note so far in the second half of the week and managed to advance to fresh weekly highs in levels just shy of the 1.1100 mark earlier in the session.
EUR/USD up on trade hopes
Spot continues to reverse Wednesday’s pullback although the bullish attempt has run out of steam at the very doorsteps of 1.1100 the figure.
The earlier move up was on the back of positive headlines from the US-China trade front, as rumours were citing the probability that the December tariffs could be delayed at the same time when Chinese and US negotiators are assessing the idea of resuming trade talks.
On the docket, the minutes of the latest ECB meeting noted members advocated for patience following the restart of the QE programme, although they acknowledged the precarious outlook on both the global and domestic economy. Later in the session, the European Commission is expected to release its measure of Consumer Confidence.
Across the ocean, the Philly Fed manufacturing index came in above estimates at 10.4 for the month of November, while Initial Claims once again rose above forecasts at a weekly 227K.
What to look for around EUR
Spot met strong resistance in the 1.1080/90 band for the time being while it keeps looking to USD-dynamics and headlines from the US-China trade front for direction. On the macro view, the outlook in Euroland remains fragile and does nothing but justify the ‘looser for longer’ monetary stance by the ECB and the bearish view on the single currency in the medium term at least. In this regard, all the looks will be upon the release of November’s preliminary PMIs later in the week.
EUR/USD levels to watch
At the moment, the pair is gaining 0.01% at 1.1072 and faces the next hurdle at 1.1097 (monthly high Nov.21) followed by 1.1173 (200-day SMA) and finally 1.1179 (monthly high Oct.21). On the downside, a break below 1.0989 (monthly low Nov.14) would target 1.0925 (low Sep.3) en route to 1.0879 (2019 low Oct.1).


public static final class R.string
extends java.lang.Object
| Constructor and Description |
|---|
string() |
public static final int AddSessionField
public static final int AddTutorSession
public static final int AvailableSessionsButton
public static final int Availible
public static final int BidButton
public static final int BidsOnMySessionsField
public static final int CancelButton
public static final int ClearDeclinedBidsField
public static final int CreateProfileField
public static final int CurrentBidsButton
public static final int DeleteButton
public static final int DescriptionField
public static final int EditButton
public static final int EditProfileButton
public static final int EditProfileField
public static final int EditSessionField
public static final int EmailField
public static final int EnterBidField
public static final int MyProfileButton
public static final int MySessionsButton
public static final int NewEmailField
public static final int NewPhoneField
public static final int NewUsernameField
public static final int PhoneField
public static final int PostedByField
public static final int RepostButton
public static final int SaveButton
public static final int SearchButton
public static final int SearchKeywordsHint
public static final int SessionField
public static final int StatusField
public static final int StudentRatingField
public static final int SubjectField
public static final int TutorRatingField
public static final int UsernameField
public static final int ViewBidsField
public static final int abc_action_bar_home_description
public static final int abc_action_bar_home_description_format
public static final int abc_action_bar_home_subtitle_description_format
public static final int abc_action_bar_up_description
public static final int abc_action_menu_overflow_description
public static final int abc_action_mode_done
public static final int abc_activity_chooser_view_see_all
public static final int abc_activitychooserview_choose_application
public static final int abc_capital_off
public static final int abc_capital_on
public static final int abc_search_hint
public static final int abc_searchview_description_clear
public static final int abc_searchview_description_query
public static final int abc_searchview_description_search
public static final int abc_searchview_description_submit
public static final int abc_searchview_description_voice
public static final int abc_shareactionprovider_share_with
public static final int abc_shareactionprovider_share_with_application
public static final int abc_toolbar_collapse_description
public static final int action_settings
public static final int app_name
public static final int appbar_scrolling_view_behavior
public static final int auth_google_play_services_client_facebook_display_name
public static final int auth_google_play_services_client_google_display_name
public static final int common_google_play_services_api_unavailable_text
public static final int common_google_play_services_enable_button
public static final int common_google_play_services_enable_text
public static final int common_google_play_services_enable_title
public static final int common_google_play_services_install_button
public static final int common_google_play_services_install_text_phone
public static final int common_google_play_services_install_text_tablet
public static final int common_google_play_services_install_title
public static final int common_google_play_services_invalid_account_text
public static final int common_google_play_services_invalid_account_title
public static final int common_google_play_services_network_error_text
public static final int common_google_play_services_network_error_title
public static final int common_google_play_services_notification_ticker
public static final int common_google_play_services_restricted_profile_text
public static final int common_google_play_services_restricted_profile_title
public static final int common_google_play_services_sign_in_failed_text
public static final int common_google_play_services_sign_in_failed_title
public static final int common_google_play_services_unknown_issue
public static final int common_google_play_services_unsupported_text
public static final int common_google_play_services_unsupported_title
public static final int common_google_play_services_update_button
public static final int common_google_play_services_update_text
public static final int common_google_play_services_update_title
public static final int common_google_play_services_updating_text
public static final int common_google_play_services_updating_title
public static final int common_google_play_services_wear_update_text
public static final int common_open_on_phone
public static final int common_signin_button_text
public static final int common_signin_button_text_long
public static final int google_maps_key
public static final int hello_world
public static final int status_bar_notification_info_overflow
public static final int titleBody
public static final int title_activity_create_profile
public static final int title_activity_edit_profile
public static final int title_activity_maps
public static final int title_activity_upcoming_sessions
public static final int title_activity_view_maps
public static final int title_activity_view_one_upcoming_session
public static final int upcomingSessions