Safari opens hypermarket in Al Khor with many special offers
Doha: Leading hypermarket chain Safari Group opened its 4th hypermarket in Qatar yesterday as thousands thronged the Al Khor outlet for the special offers. The one of a kind ‘Visit and Win’ promotion has become a big hit among the visitors.
The hypermarket in Al Khor was inaugurated by Sheikh Mohammed bin Ahmed bin Jassim Al Thani yesterday.
Safari Group Chairman Hamad Dafar A A Al Ahbabi, Managing Director Aboobacker Madappatt, Safari Group Director and General Manager Zainul Abideen, Executive Directors Shaheen Backer and Shameem Backer, and other officials were present during the opening cereony.
For the inauguration, there are many exciting offers and promotions for customers.
The occasion saw large crowds turn up at the hypermarket to make the most of the special promotions offered to mark the opening. The hypermarket was giving away 32-inch LED TV for QR189 and laptop for QR 599.
Safari ‘Visit and Win’ promotion kicked off yesterday. Customers visiting the new Safari in Al Khor can win a Lexus LX 570SUV by just visiting the hypermarket. The highlight of this promotion is that one need not purchase anything from Safari to get lucky. Visitors receives coupon from customer service and can try their luck in the draw.
The new Hypermarket is operational on four floors covering 193,000 square feet. The basement also has spacious car parking for customers. The ground floor is a supermarket and the first floor is department store. Second floor is for food court.
“This is the first of its kind lucky draw in the country. Offer, which started yesterday is on till January 19, 2020. The winner will be announced at the draw on January 20 at Safari in Al Khor,” a statement from the group said.
Another mega promotion started from November 20, where as many as 20 Toyota Corolla cars will be rewarded with a coupon offer from Safari branches for every purchase of QR50. Unlike usual practice, three Toyota Corolla cars are being gifted every 15 days.
The first three draws will take place at Safari’s Al Khor branch and the next four draws will be at the Safari Mall in Abu Hamour.
Safari, with many years of experience in retail, offers a range of products to suit the needs of its customers. Safari’s success story is that providing all world class products under one roof with affordable price which suits every one’s budget. Safari has a dedicated team of experienced professionals to market a variety of products to meet the needs, tastes and budgets of customers. The advantage is that consumer can by quality products within the limit of their budget.
Read also
Read More
New Safari Hypermarket opens in Al Khor
Safari Group opened its 4th Hypermarket in Al Khor, yesterday.
Read More
AAB hosts Hybrid Familiarisation Program for corporate customers
Abdullah Abdulghani & Bros. Co. (AAB) sole agents for Toyota vehicles in Qatar organised a Hybrid Familiarisation Program for their top corporate customers. The event held at The Westin Doha Hotel was attended by was attended by senior officials from various companies including Rent a Car, Limousine Companies etc.
Read More
New Safari Hypermarket to be inaugurated in Al Khor on Wednesday
Safari Group is opening its 4th Hypermarket in Al Khor on Wednesday at 11am. Sheikh Khalifa bin Jassim bin Mohammed Al Thani, Chairman of Qatar Chamber of Commerce will cut the ribbon to open new Safari Hypermarket.


The film took more than three years to shoot and is the result of 500+ hours of underwater footage, coral bleaching submissions from volunteers in 30 countries, as well as support from more than 500 people in various locations around the world.


boris johnson
Congratulations to Boris Johnson on becoming the new Prime Minister of the United Kingdom. He will be great!
Boris Johnson has won the support of fewer than 100,000 unrepresentative Conservative Party members by promising tax cuts for the richest, presenting himself as the bankers' friend, and pushing for a damaging No Deal Brexit.
But he hasn't won the support of our country.
The News: Boris Johnson becoming PM; Britain heading for hottest day in its history. Or to put it another way: we are literally entering hell.
6,000,000 sign petition to revoke Article 50:
"Means nothing"
92,153 votes in favour of Boris Johnson:
"THIS IS A CLEAR MANDATE FOR NO DEAL"
Boris Johnson's coronation as Tory leader and Prime Minister is a sad indictment of the state of modern Britain.
Even after a career marked by incompetence, lies and vanity, if you have been to the right school and university, you can get the top job in the country. https://t.co/LXlTA04FTz
hackathon
💻 23,500+ registered hackers
🚧 5,800+ hackathon projects
🌎 75 countries
🏙 400+ cities
This week, employees from around the world are participating in our annual #hackathon to explore their creativity and passions. #MicrosoftLife https://t.co/0C6MreG9bq
Today marks the start of @Microsoft’s #Hackathon! Employees and interns focus their energies on collaboration, creativity and experimentation by “hacking” for good, participating in challenges that work to advance ideas and solve real-world problems. https://t.co/WN2g7BIpdN
#HackSerpro A inovação dos serviços públicos com inteligência artificial! Esse foi o primeiro dia do Hackathon Serpro @bioticsa @unb_oficial @CotidianoSocial @TCU https://t.co/546g3NuNxN
Hey #Insiders, greetings from Day 1 of the 2019 @Microsoft Hackathon! Check back here and follow us on Instagram @windowsinsider for updates from the field so you don't miss what our #Insiders2Campus contest winners get up to as they hack alongside us all week @MSFTGarage https://t.co/S9SZykSUr7
Entering into the final hours of the @Microsoft #Hackathon and feeling extra grateful for our #WindowsInsider teams for bringing their talents, smarts, and energy to solve complex challenges @MSFTGarage @CustomerSpaul @clintroy_mkt @Ninjamark23 https://t.co/6q75PFBtxt


Surrey RCMP looking for missing 70-year-old man
Police say Arpad “R.P.” Sator was last seen at 4 p.m. on Nov. 28 in the 15100-block of Highway 10
by Amy ReidSurrey RCMP is asking for helping in finding a missing 70-year-old man.
Police say Arpad “R.P.” Sator was last seen at 4 p.m. on Nov. 28 in the 15100-block of Highway 10 in Surrey.
He has not been seen or heard from since.
Sator is described as Caucasian, five feet six inches tall, 157 pounds, with thin white hair and blue eyes.

Police and family are concerned for his health and well-being.
Anyone with information on his whereabouts is asked to contact the Surrey RCMP at<PHONE_NUMBER>, or Crime Stoppers, to remain anonymous, at 1-800-222-8477 or solvecrime.ca, quoting file number 2019-184711.


Spectral Correlated Noise¶
-
class
galsim.
CovarianceSpectrum
(Sigma, SEDs)[source]¶ Class to hold a
ChromaticSum
noise covariance spectrum (which is a generalization of a power spectrum or equivalently a correlation function).Analogous to how a
galsim.CorrelatedNoise
object stores the variance and covariance of agalsim.Image
object, agalsim.CovarianceSpectrum
stores the variance and covariance of the Fourier mode amplitudes in different components of aChromaticSum
.Note that the covariance in question exists between different
SED
components of theChromaticSum
, and not between different Fourier modes, which are assumed to be uncorrelated. This structure arises naturally for aChromaticRealGalaxy
(see devel/modules/CGNotes.pdf for more details).- Parameters
Sigma – A dictionary whose keys are tuples numerically indicating a pair of
ChromaticSum
components whose Fourier mode amplitude covariances are described by the correspondingGSObject
values.SEDs –
SED
instances of associatedChromaticSum
components.
-
toNoise
(bandpass, PSF, wcs, rng=None)[source]¶ Derive the
CorrelatedNoise
object for the associatedChromaticSum
when convolved withPSF
and drawn throughbandpass
onto pixels with specifiedwcs
.- Parameters
bandpass –
Bandpass
object representing filter image is drawn through.PSF – output chromatic PSF to convolve by.
wcs – WCS of output pixel scale.
rng – Random number generator to forward to resulting CorrelatedNoise object.
- Returns
CorrelatedNoise object.


Salmon Cookie Sales
Store Sales By Hour
Return to Store
Add a New Cookie Stand
Location
Min Customers an Hour
Max Customers an Hour
Average Cookies Bought
Submit


JavaScript is disabled on your browser.
Skip navigation links
Overview
Package
Class
Tree
Deprecated
Index
Help
Prev
Next
Frames
No Frames
All Classes
mas-foundation API
Packages
Package
Description
com.ca.mas.core
com.ca.mas.core.auth
com.ca.mas.core.auth.ble
com.ca.mas.core.auth.otp
com.ca.mas.core.auth.otp.model
com.ca.mas.core.cert
com.ca.mas.core.client
com.ca.mas.core.clientcredentials
com.ca.mas.core.conf
com.ca.mas.core.context
com.ca.mas.core.datasource
com.ca.mas.core.ent
com.ca.mas.core.error
com.ca.mas.core.http
com.ca.mas.core.io
com.ca.mas.core.io.http
com.ca.mas.core.io.ssl
com.ca.mas.core.oauth
com.ca.mas.core.policy
com.ca.mas.core.policy.exceptions
com.ca.mas.core.registration
com.ca.mas.core.request
com.ca.mas.core.request.internal
com.ca.mas.core.security
com.ca.mas.core.service
com.ca.mas.core.storage
com.ca.mas.core.storage.implementation
com.ca.mas.core.storage.sharedstorage
com.ca.mas.core.store
com.ca.mas.core.token
com.ca.mas.core.util
com.ca.mas.foundation
com.ca.mas.foundation.auth
com.ca.mas.foundation.notify
com.ca.mas.identity
com.ca.mas.identity.common
com.ca.mas.identity.group
com.ca.mas.identity.user
com.ca.mas.identity.util
com.ca.mas.messaging
com.ca.mas.messaging.topic
sun.misc
sun.security.action
sun.security.ec
sun.security.pkcs
sun.security.provider
sun.security.provider.certpath
sun.security.util
sun.security.x509
sun.util.calendar
Skip navigation links
Overview
Package
Class
Tree
Deprecated
Index
Help
Prev
Next
Frames
No Frames
All Classes


If the PIR sensor detects people move, the light in the sensor and user-page will be on, and buzzer starts buzzing


clear and on are state predicates, while move is an action predicate. The axioms which specify the problem can be grouped into 4 categories:
The last group of actions is redundant, but has been found to be useful for speeding up local search. For a given blocks world planning instance, instantiating the predicates listed above gives the propositional variables over which the axioms can then be formulated as CNF clauses.
The SAT encoding used for generating the benchmark problems relies critically on two important techniques for reducing the size of the CNF formulae: operator splitting [KMS96] and simple propositional reductions (unit propagation and subsumption). Operator splitting replaces a predicate which take three or more arguments by a number of binary predicates. This reduces the number of propositional variables for the given problem from O(kn^3) to O(kn^2) where n is the number of blocks and k the number of plan steps. Unit propagation and subsumptions, two well-known propositional reduction strategies, are used to simplify the formulae before applying stochastic local search. These reducations can be computed in polynomial time and eliminate a number of propositional variables thus efficiently reducing the search space. Intuitively, these by applying these strategies the initial and goal states are propagated into the planning structure. Details on the SAT encoding used to generate the benchmark problems can be found in [KS96,KMS96].
Our benchmark set contains 7 blocks world planning instances taken from Henry Kautz' and Bart Selman's SATPLAN distribution. These instances are described in Table 1; despite the reductions mentioned above, they are still very large when compared to other instances of our benchmark suit. bw_large.c and bw_large.d belong to the hardest problems which can be solved by state-of-the-art SAT algorithms in reasonable time.
| instance | blocks | steps | vars | clauses |
| anomaly | 3 | 3 | 48 | 261 |
| medium | 5 | 4 | 116 | 953 |
| bw_large.a | 9 | 6 | 459 | 4,675 |
| huge | 9 | 6 | 459 | 7,054 |
| bw_large.b | 11 | 9 | 1,087 | 13,772 |
| bw_large.c | 15 | 14 | 3,016 | 50,457 |
| bw_large.d | 19 | 18 | 6,325 | 131,973 |
Table 1: SAT-encoded Blocks World Planning instances (linear encoding), contributed by Henry Kautz and Bart Selman (all instances are satisfiable).
| [KS96] | Henry Kautz and Bart Selman
Pushing the Envelope: Planning, Propositional Logic, and Stochastic Search.
Proc. AAAI-96, pages 1194--1201, 1996 |
| [KMS96] | Henry Kautz and David McAllester and Bart Selman
Encoding Plans in Propositional Logic.
Proc. KR-96, pages 374--384, 1996 |


Walking Leo
Kareem, Rayan and I emerge onto the street out of the ominous black gates of their house on Grove End Road, and head east towards the tube stop. Leo is golden, glowing with perfect precision, and pulls Rayan along. We are talking, or maybe rather I am talking, non-stop, and I am holding a skateboard. How many times have we walked this path before?
There is a cricket game at Lord’s Cricket Ground and everyone is blobbed in our way as we walk past the station, wearing those orange-and-yellow-striped ties that everyone wears when there’s a game at Lord’s. We all agree we don’t know why everyone wears them when there’s a game at Lord’s. We turn south off Acacia Road onto St. Anne’s Terrace, which becomes the High Street. The Duke of York bursts with people who either want to watch the game or already saw it. Rayan and Leo are briefly lost in the crowd, possibly stuck, and I deeply empathize with Rayan’s stuckness, but am too delighted to emerge from the crowd myself to try to help him. He emerges several seconds later anyways, Leo tugging him out by the lead.
We turn onto the cobbled Charles Lane, just south of Gelato Mio, still talking. Several small children once tried to mug me, Shahid and Tina here. At the end of it, we turn right, and going south on Charlbert Street there is a miraculous conflux at its intersection with Allitsen Road, wherein Mo and Adib park right next to where we are walking and yell something that makes us jump before we realize it’s them. Two women in hijabs walk by, and they grin at something Mo says to them in Arabic as he gets out of the car. I don’t know Mo but he has a very thin nose and is wearing a fedora. Adib is just so happy to see Leo, and after all it’s a beautiful and gorgeous day that occasionally vibrates with satisfaction. Leo is grinning, and he’s happy to see Adib as well. We walk towards the New Inn, where Adib and Mo want to get a pint or something. Kareem’s hair is insane. I think I give Adib my American phone number because we’re going to meet them later.
We keep going down Charlbert and finally get to the park, and I skateboard down the little hill, and then the bridge across the canal, and up to the Outer Circle road. The small greebles of the pavement vibrate up through the wheels and massage my feet. There’s something electric about concrete with moss growing out of it that makes itself known to me. I wait for the twins, and we cross the road together. Rayan lets Leo off the lead, and he surges forward, sprinting, and then jumps over the fence and then jumps back over and heads for the thick of the park. Rayan and Kareem walk on either side of me as I roll on the skateboard. Leo stops way ahead of us on the path to look back at Rayan, posing in the dappled tree light and smiling. He waits for a few seconds and then hurls himself forwards again towards the grass and the people. There are so many people. Ohh no Rayan says, because Leo is, like, in someone’s picnic. Everyone is playing softball, including the woman guarding the picnic. She doesn’t seem to be too bothered by Leo even though I strongly feel that he ate something, but she doesn’t have a real face right now so it’s hard to tell.
Now we are walking again, Leo back on the lead because it must be softball day in the park and there are all these people from America acting like Americans. Seven glistening shirtless men with tiny shorts come charging at us on the path, and I know they are going to trample us or stick us with spears. They are in a pack, I don’t know, primordial warriors or something. But they are just training. I want to tell them it’s irresponsible to run in a pack like that because it’s terrifying. We stop and watch a softball game for a while. Kareem’s hair is like small-knotted rams’ horns, and he has dark rings under his eyes. Softball, I have just realized, is very very interesting.
The team fielding the ball right now is a single organic machine that stops the ball midflight, absorbs its momentum with an elasticity that flings the ball back to home at the same speed it left. We stare at them for a long time, entranced, discussing softball. The men in tiny shorts seem to be doing laps, and keep running past us as we head to where the Honest Sausage used to be. With each pass, they are still causing me to feel the wide-eyed terror of a sheep about to be slaughtered, but I’m getting used to it. I get back on the skateboard and a breeze kicks up at my back. The grass is so rich with color it ripples. I kick forward again and I can feel my t-shirt billowing deliberately. I take the left fork of the path, ride along the pavement between fields of tall yellow-tipped grass, soaring, the tear-dropped flaxen tips so fine that they never reach a point.
Now Mo and Adib have found us. Adib is really angry because he tossed back a stray softball that rolled onto the path, and no one said thank you. We carry on, following the curved path that will bring us alongside the zoo. The trees begin arching over our heads. Like the grass, and Leo’s beautiful golden hair, their leaves seem too precise to find completion. Flashes of sharpness glow where the sun sifts through the upper canopy. How’s Saudi, Mo? Kareem asks. Mo doesn’t like it, he says. We all agree we love St. John’s Wood. Some animals in the zoo make noises. In the shifting, layered procession of large walking groups, Kareem falls back towards Adib, I am talking to Mo. He works for a defense contractor in Saudi, and he explains what that means. I nod, smiling. It is completely incomprehensible to me.
Adib, Mo and Leo go off with Adib’s girlfriend to Primrose Hill, but we head back to Kareem and Rayan’s place where we have forgotten that Julian is waiting for us.


over 10.000 registered house find rental house with rental search engine find house no need to visit real estate agencies find rental house with rental search engine find house near you anytime anywhere all in one user experience. compatiple with all mobile devices wish to use


 It should have two files.
The next command you have to learn is git status
. This command reports the difference between the working directory, the staging index, and the repository.
git status
You should see a message like this:
# On branch master
nothing to commit (working directory clean)
This means that the working directory exactly matches what is in the repository
Now let's add more files:
file3.txt
and file4.txt
git status
Add just the file file3.txt
, and then check the status
git add file3.txt
git status
At this point, the status shows two parts: the staged changes (ready to be commited), and the untracked files (which are not being tracked)
Let's commit the staged changes with a message, and then see the status
git commit -m "add file3 to the project"
git status
You can also look at the commits log
git log
Your turn: Add the fourth file, check the status, commit the changes, check status again, and see the log.
 Adding git status
to the workflow completes the process:
We've seen how to add and commit new files. However, in practice is very common to make changes to existing files, or even deleting some files. It is important to understand how Git tracks these types of modifications.
In this part we are going to edit some files and see how Git works with those changes.
So far we have four files in our toy_project
: file1.txt
, ..., file4.txt
. Let's modify the contents of file1.txt
(e.g. add a quote). Once you change the file, let's check the status:
git status
As you can tell, Git tells you that file1.txt
has been modified. Add the changes and commit them:
git add file1.txt
git commit -m 'add quote to file1.txt'
Modify file2.txt
by adding a telephone number, and add the change (but don't commit it yet)
git add file2.txt
Before commiting the previous change, modify file3.txt
as well by adding the name of one of your favorite movies. If you do git status
you will see that the modified file2.txt
is in the staged directory while the modified file3.txt
is just in the working directory.
Commit the change of the second file (not file3.txt
).
git commit -m 'added a telephone number in file2.txt'
git status
Finally, let's add and commit the modified file3.txt
git add file3.txt
git commit -m 'added favorite movie to file3.txt'
Let's make more edits to file1.txt
, say, adding the city where you were born. If you do git status
, you know that Git will report that file1.txt
has been modified.
In order to see the difference between what's in the staging index versus what is in the working directory, you can use git diff
git diff
Take some time to look at the output and understand what's going on.
Make some changes to file2.txt
, for instance, adding the name of your major.
git diff
If you want to get the changes of just the first file, then type
git diff file1.txt
Let's add file1.txt
to the staging index and see the differences again:
git add file1.txt
git diff
Notice that git diff
only shows the changes in file2.txt
How do we see the modifications in file1.txt
? Simple use the option --staged
git diff --staged
Now add file2.txt
git add file2.txt
git status
git diff
Create two more files; these will be deleted after being added and committed to the repository.
touch dummy1.txt dummy2.txt
git status
git add .
git commit -m 'adding dummy files'
Let's look at the naive way to delete a file.
rm dummy1.txt
git status
Now try adding the deleted file:
git add dummy1.txt
To actually add the changes to the staging area we need to:
git rm dummy1.txt
git status
Now we can commit:
git commit -m 'deleted dummy1.txt'
git status
The other way to delete is using git rm
which will delete the file and record the changes in the staging index:
git rm dummy2.txt
git status
After that you can commit:
git commit -m 'delete dummy2.txt'
git mv


--- layout: post esbma_id: 1154 title: Act Your Age date: 2003-07-09 01:08:53 keywords: mfg_strategy book_marketing teaser: But step three is something that happens to your product whether you like it or not. Not unlike the natural aging process we experience as human beings, our products go through various stages of life. In both cases, the only way to avoid the next stage is death, so we might as well learn to handle these stages with a measure of grace. ---
This article is part of a series entitled "Marketing for Geeks". The central theme is that if we demystify marketing, it can be competently done by technical people.
Most geeks tend to shy away from marketing, citing their lack of creativity and graphic design skills. But these are typically not the differentiators which determine whether marketing is competent or not. Marketing efforts tend to succeed or fail on their strategy and tactics, not on their artwork. Before you start designing logos or wordsmithing your ad copy, you need to do three things:
The first two steps were explained in previous articles. In both, you have the luxury of choices. You get to choose your market segment. You get to define your product's position.
But step three is something that happens to your product whether you like it or not. Not unlike the natural aging process we experience as human beings, our products go through various stages of life. In both cases, the only way to avoid the next stage is death, so we might as well learn to handle these stages with a measure of grace.
Four Groups
The people in your market segment are divided into four groups:
Early Adopters are risk takers who actually like to try new things.
Pragmatists might be willing to use new technology, if it's the only way to get their problem solved.
Conservatives dislike new technology and try to avoid it.
Laggards pride themselves on the fact that they are the last to try anything new.
Marketing textbooks usually draw these groups using a bell curve, something like this:
The bell curve highlights two important things:
1. The middle two groups account for most of your potential customers.
2. You can only get these customers in order, moving from left to right.
Each of the four groups has its own behavior which determines when they will buy your product:
The Chasm
To be successful, you eventually have to sell your product to the Pragmatists and Conservatives, but these two groups behave very differently from the groups on the ends of the bell curve. Specifically, the middle two groups function with a "herd mentality". They are followers. They only buy when they see somebody else doing it.
The Conservatives are actually not all that difficult. They watch the Pragmatists very closely. They'll start buying after most of the Pragmatists are happy with your product. You don't have to do any special gymnastics to attract the Conservatives. Once the Pragmatists like you, then the Conservatives will follow.
The Pragmatists are the real problem group. They are followers, but the only people they're willing to follow are each other. It's tempting to think they will simply wait for the group ahead of them to like your product, but it's not true. The endorsement of the Early Adopters is not enough. Like a junior high dance, the Pragmatists are watching each other, waiting for somebody else to make the first move.
This dynamic is very well explained by Geoffrey Moore in his outstanding book Crossing the Chasm. Moore argues that the classic marketing bell curve is wrong, and should actually be rendered more like this:
This drawing reflects the fact that there is no smooth or logical transition between the Early Adopters and the Pragmatists. In between the Early Adopters and the Pragmatists there is a chasm. To successfully sell your product to the Pragmatists, you must "cross the chasm".
But if the Pragmatists won't buy until they see each other doing it, how we get across?
The key is to find a Pragmatist who is desperate, or as Moore says, a "Pragmatist in Pain". They have a problem, and they need it solved very badly. In fact, they are so desperate for a solution that they are willing to break ranks with their Pragmatist peers and be the first of their kind to try your product.
You need to have a very special relationship with your Pragmatist in Pain. They don't like working with small ISVs. They prefer to buy from larger vendors with established reputations. By choosing to buy your product, they are sponsoring you across the chasm. You don't really deserve to be on the other side, and they know that.
So you have to treat them like they are very special. Give them everything they want, almost as if they were ordering a custom application. You may have to implement special features just for them. You may have to give them substantial discounts. You should visit their site and meet them in person. You may have to install your product for them. Financially, this one customer will probably be a net loss. That's okay. Don't stop until they're happy.
Since crossing the chasm is so difficult, you might be tempted to think you can just stay on the left side. Maybe the Early Adopters represent a market which is big enough for your product? Sorry, but this won't work. The Early Adopters like new things, and your product is getting older every day. If you try to build your product's entire life on the Early Adopters, you take the risk that they will abandon you for somebody else who proclaims to have the latest cool thing. In the long run, it's not safe to remain on the left side of the chasm.
 The timeframe spanned by this bell curve is usually measured in years, not weeks or months. These four groups and the transitions between them represent distinct stages in the life of your product. Each of those stages is very different, and things will go much better if you behave appropriately at each stage of your product's life.
Nine year old girls don't wear heavy makeup. Sixty-five year olds don't start bachelor's degrees. Thirty-two year olds don't stay up all night like they did ten years before. (And yes, there are exceptions to each of these rules. :-) )
Similarly, products need to act their age. Choosing features is a part of marketing. When you decide what features to include in each release, you need to keep your product's current life stage in mind. Here are a few examples of what this might mean:
P.S.
My apologies to fans of Geoffrey Moore who think I have oversimplified things too much. I'm a geek trying to explain marketing to other geeks, so it seems prudent not to exceed the available precision. :-)
Readers who want lots more detail are strongly encouraged to get Crossing the Chasm as well as his followup book, Inside the Tornado, which is also very good.


V�lkommen till BurgerOnline
Select Burgers
This is where you can select which burgers you want to order.
Customer information
This is where you provide neccesary information for us to deliver your order
Click in the map!
{{key}}
This is where you can select which burgers you want to order.
This is where you provide neccesary information for us to deliver your order


Here you can generate predictions for any search conditions you like.Input a Suumo search results URL to sub
- Go to Suumo and do a property search setting any conditions you like.
- Copy the search results page URL into the form below and hit "Submit".
- The generated predictions will be shown after a few moments in the table below. Click the "View" link to see the generated predictions.
The URL starts with:
https://suumo.jp/jj/chintai/ichiran/FR301FC001/


microservices - devOps - distributed tracing
zipkin
zipkin & cassandra
Apache Cassandra the data platform de jure
for the next evolution of software services
an enterprise moving ever towards
microservices and BASE architectures
the missing piece for many is tracing and profiling difficult to reproduce problems
Apache Cassandra
data platform de jure
next evolution of software services
an enterprise moving ever towards
microservices and BASE architectures
tracing and profiling difficult to reproduce problems
an implementation of Google's Dapper paper
CS -->
--> SR
<-- SS
CR <--
CO-ORDINATOR NODE REPLICA NODE
-->
beginSession(..)
trace(..)
trace(..)
--> initialiseMessage(..)
trace(..)
trace(..)
<--
trace(..)
endSession(..)
<--
public class ZipkinTracing extends Tracing
{..}
public class ZipkinTraceState extends TraceState
{..}
bin/cassandra -Dcassandra.custom_tracing_class=..ZipkinTracing
CO-ORDINATOR NODE REPLICA NODE
-->
beginSession(..)
trace(..)
trace(..)
(zipkin headers) --> initialiseMessage(..)
trace(..)
trace(..)
<--
trace(..)
endSession(..)
<--
bin/cassandra
-Dcassandra.custom_tracing_class=..ZipkinTracing
-Dcassandra.custom_query_handler_class=..CustomPayloadMirroringQueryHandler
src/java/org/apache/cassandra/net/MessageOut.java | 7 +------
src/java/org/apache/cassandra/net/OutboundTcpConnection.java | 4 +++-
src/java/org/apache/cassandra/service/QueryState.java | 12 ++++++++++--
src/java/org/apache/cassandra/transport/messages/ExecuteMessage.java| 2 +-
4 file changed, 15 insertion(+), 10 deletion(-)


--> --> --> --> -->
|
Click on the image sequential points forming the shape to be cropped and click on CROP button.
Refresh to restart. | HERE APPEARS THE UPLOADED IMAGE |


Allows custom favicons between local, staging and production environments.
See favicon of this site for an example of this. On the live site, the favicon will be a dark blue book. On the local site, it will be a light blue book.


class Bundler::Definition
Attributes
Public Class Methods
Given a gemfile and lockfile creates a Bundler
definition
@param gemfile [Pathname] Path to Gemfile @param lockfile [Pathname,nil] Path to Gemfile.lock @param unlock [Hash, Boolean, nil] Gems that have been requested
to be updated or true if all gems should be updated
@return [Bundler::Definition]
# File lib/bundler/definition.rb, line 27 def self.build(gemfile, lockfile, unlock) unlock ||= {} gemfile = Pathname.new(gemfile).expand_path raise GemfileNotFound, "#{gemfile} not found" unless gemfile.file? Dsl.evaluate(gemfile, lockfile, unlock) end
How does the new system work?
-
Load information from Gemfile and Lockfile
-
Invalidate stale locked specs
-
All specs from stale source are stale
-
All specs that are reachable only through a stale dependency are stale.
-
If all fresh dependencies are satisfied by the locked
specs, then we can try to resolve locally.
@param lockfile [Pathname] Path to Gemfile.lock @param dependencies [Array(Bundler::Dependency
)] array of dependencies from Gemfile @param sources [Bundler::SourceList] @param unlock [Hash, Boolean, nil] Gems that have been requested
to be updated or true if all gems should be updated
@param ruby_version
[Bundler::RubyVersion, nil] Requested Ruby Version @param optional_groups [Array(String)] A list of optional groups
# File lib/bundler/definition.rb, line 54 def initialize(lockfile, dependencies, sources, unlock, ruby_version = nil, optional_groups = [], gemfiles = []) if [true, false].include?(unlock) @unlocking_bundler = false @unlocking = unlock else unlock = unlock.dup @unlocking_bundler = unlock.delete(:bundler) unlock.delete_if {|_k, v| Array(v).empty? } @unlocking = !unlock.empty? end @dependencies = dependencies @sources = sources @unlock = unlock @optional_groups = optional_groups @remote = false @specs = nil @ruby_version = ruby_version @gemfiles = gemfiles @lockfile = lockfile @lockfile_contents = String.new @locked_bundler_version = nil @locked_ruby_version = nil @locked_specs_incomplete_for_platform = false @new_platform = nil if lockfile && File.exist?(lockfile) @lockfile_contents = Bundler.read_file(lockfile) @locked_gems = LockfileParser.new(@lockfile_contents) @locked_platforms = @locked_gems.platforms @platforms = @locked_platforms.dup @locked_bundler_version = @locked_gems.bundler_version @locked_ruby_version = @locked_gems.ruby_version if unlock != true @locked_deps = @locked_gems.dependencies @locked_specs =<EMAIL_ADDRESS>@locked_sources = @locked_gems.sources else @unlock = {} @locked_deps = {} @locked_specs = SpecSet.new([]) @locked_sources = [] end else @unlock = {} @platforms = [] @locked_gems = nil @locked_deps = {} @locked_specs = SpecSet.new([]) @locked_sources = [] @locked_platforms = [] end @locked_gem_sources = @locked_sources.select {|s| s.is_a?(Source::Rubygems) } @disable_multisource = @locked_gem_sources.all?(&:disable_multisource?) unless @disable_multisource msg = "Your lockfile contains a single rubygems source section with multiple remotes, which is insecure. You should run `bundle update` or generate your lockfile from scratch." Bundler::SharedHelpers.major_deprecation 2, msg @sources.merged_gem_lockfile_sections! end @unlock[:gems] ||= [] @unlock[:sources] ||= [] @unlock[:ruby] ||= if @ruby_version && locked_ruby_version_object @ruby_version.diff(locked_ruby_version_object) end @unlocking ||= @unlock[:ruby] ||= (!@locked_ruby_version ^ !@ruby_version) add_current_platform unless current_ruby_platform_locked? || Bundler.frozen_bundle? converge_path_sources_to_gemspec_sources @path_changes = converge_paths @source_changes = converge_sources unless @unlock[:lock_shared_dependencies] eager_unlock = expand_dependencies(@unlock[:gems], true) @unlock[:gems] = @locked_specs.for(eager_unlock, [], false, false, false).map(&:name) end @dependency_changes = converge_dependencies @local_changes = converge_locals @requires = compute_requires end
Public Instance Methods
# File lib/bundler/definition.rb, line 474 def add_platform(platform) @new_platform ||= !@platforms.include?(platform) @platforms |= [platform] end
# File lib/bundler/definition.rb, line 244 def current_dependencies dependencies.select do |d| d.should_include? && !d.gem_platforms(@platforms).empty? end end
# File lib/bundler/definition.rb, line 255 def dependencies_for(groups) current_dependencies.reject do |d| (d.groups & groups).empty? end end
# File lib/bundler/definition.rb, line 159 def disable_multisource? @disable_multisource end
# File lib/bundler/definition.rb, line 361 def ensure_equivalent_gemfile_and_lockfile(explicit_flag = false) msg = String.new msg << "You are trying to install in deployment mode after changing\n" \ "your Gemfile. Run `bundle install` elsewhere and add the\n" \ "updated #{Bundler.default_lockfile.relative_path_from(SharedHelpers.pwd)} to version control." unless explicit_flag suggested_command = if Bundler.settings.locations("frozen").keys.&([:global, :local]).any? "bundle config unset frozen" elsif Bundler.settings.locations("deployment").keys.&([:global, :local]).any? "bundle config unset deployment" end msg << "\n\nIf this is a development machine, remove the #{Bundler.default_gemfile} " \ "freeze \nby running `#{suggested_command}`." end added = [] deleted = [] changed = [] new_platforms = @platforms - @locked_platforms deleted_platforms = @locked_platforms - @platforms added.concat new_platforms.map {|p| "* platform: #{p}" } deleted.concat deleted_platforms.map {|p| "* platform: #{p}" } gemfile_sources = sources.lock_sources new_sources = gemfile_sources - @locked_sources deleted_sources = @locked_sources - gemfile_sources new_deps = @dependencies - @locked_deps.values deleted_deps = @locked_deps.values - @dependencies # Check if it is possible that the source is only changed thing if (new_deps.empty? && deleted_deps.empty?) && (!new_sources.empty? && !deleted_sources.empty?) new_sources.reject! {|source| (source.path? && source.path.exist?) || equivalent_rubygems_remotes?(source) } deleted_sources.reject! {|source| (source.path? && source.path.exist?) || equivalent_rubygems_remotes?(source) } end if @locked_sources != gemfile_sources if new_sources.any? added.concat new_sources.map {|source| "* source: #{source}" } end if deleted_sources.any? deleted.concat deleted_sources.map {|source| "* source: #{source}" } end end added.concat new_deps.map {|d| "* #{pretty_dep(d)}" } if new_deps.any? if deleted_deps.any? deleted.concat deleted_deps.map {|d| "* #{pretty_dep(d)}" } end both_sources = Hash.new {|h, k| h[k] = [] } @dependencies.each {|d| both_sources[d.name][0] = d } @locked_deps.each {|name, d| both_sources[name][1] = d.source } both_sources.each do |name, (dep, lock_source)| next if lock_source.nil? || (dep && lock_source.can_lock?(dep)) gemfile_source_name = (dep && dep.source) || "no specified source" lockfile_source_name = lock_source changed << "* #{name} from `#{gemfile_source_name}` to `#{lockfile_source_name}`" end reason = change_reason msg << "\n\n#{reason.split(", ").map(&:capitalize).join("\n")}" unless reason.strip.empty? msg << "\n\nYou have added to the Gemfile:\n" << added.join("\n") if added.any? msg << "\n\nYou have deleted from the Gemfile:\n" << deleted.join("\n") if deleted.any? msg << "\n\nYou have changed in the Gemfile:\n" << changed.join("\n") if changed.any? msg << "\n" raise ProductionError, msg if added.any? || deleted.any? || changed.any? || !nothing_changed? end
# File lib/bundler/definition.rb, line 144 def gem_version_promoter @gem_version_promoter ||= begin locked_specs = if unlocking? && @locked_specs.empty? &&<EMAIL_ADDRESS># Definition uses an empty set of locked_specs to indicate all gems # are unlocked, but GemVersionPromoter needs the locked_specs # for conservative comparison<EMAIL_ADDRESS>else @locked_specs end GemVersionPromoter.new(locked_specs, @unlock[:gems]) end end
# File lib/bundler/definition.rb, line 292 def groups dependencies.map(&:groups).flatten.uniq end
# File lib/bundler/definition.rb, line 284 def has_rubygems_remotes? sources.rubygems_sources.any? {|s| s.remotes.any? } end
# File lib/bundler/definition.rb, line 296 def lock(file, preserve_unknown_sections = false) contents = to_lock # Convert to \r\n if the existing lock has them # i.e., Windows with `git config core.autocrlf=true` contents.gsub!(/\n/, "\r\n") if @lockfile_contents.match("\r\n") if @locked_bundler_version locked_major = @locked_bundler_version.segments.first current_major = Gem::Version.create(Bundler::VERSION).segments.first if updating_major = locked_major < current_major Bundler.ui.warn "Warning: the lockfile is being updated to Bundler #{current_major}, " \ "after which you will be unable to return to Bundler<EMAIL_ADDRESS>end end preserve_unknown_sections ||= !updating_major && (Bundler.frozen_bundle? || !(unlocking? || @unlocking_bundler)) return if file && File.exist?(file) && lockfiles_equal?(@lockfile_contents, contents, preserve_unknown_sections) if Bundler.frozen_bundle? Bundler.ui.error "Cannot write a changed lockfile while frozen." return end SharedHelpers.filesystem_access(file) do |p| File.open(p, "wb") {|f| f.puts(contents) } end end
# File lib/bundler/definition.rb, line 327 def locked_bundler_version if @locked_bundler_version && @locked_bundler_version < Gem::Version.new(Bundler::VERSION) new_version = Bundler::VERSION end new_version || @locked_bundler_version || Bundler::VERSION end
# File lib/bundler/definition.rb, line 335 def locked_ruby_version return unless ruby_version if @unlock[:ruby] || !@locked_ruby_version Bundler::RubyVersion.system else @locked_ruby_version end end
# File lib/bundler/definition.rb, line 344 def locked_ruby_version_object return unless @locked_ruby_version @locked_ruby_version_object ||= begin unless version = RubyVersion.from_string(@locked_ruby_version) raise LockfileError, "The Ruby version #{@locked_ruby_version} from " \ "#{@lockfile} could not be parsed. " \ "Try running bundle update --ruby to resolve this." end version end end
# File lib/bundler/definition.rb, line 210 def missing_specs missing = [] resolve.materialize(requested_dependencies, missing) missing end
# File lib/bundler/definition.rb, line 216 def missing_specs? missing = missing_specs return false if missing.empty? Bundler.ui.debug "The definition is missing #{missing.map(&:full_name)}" true rescue BundlerError => e @resolve = nil @specs = nil @gem_version_promoter = nil Bundler.ui.debug "The definition is missing dependencies, failed to resolve & materialize locally (#{e})" true end
# File lib/bundler/definition.rb, line 484 def most_specific_locked_platform @platforms.min_by do |bundle_platform| platform_specificity_match(bundle_platform, local_platform) end end
# File lib/bundler/definition.rb, line 202 def new_specs specs - @locked_specs end
# File lib/bundler/definition.rb, line 496 def nothing_changed? !@source_changes && !@dependency_changes && !@new_platform && !@path_changes && !@local_changes && !@locked_specs_incomplete_for_platform end
# File lib/bundler/definition.rb, line 479 def remove_platform(platform) return if @platforms.delete(Gem::Platform.new(platform)) raise InvalidOption, "Unable to remove the platform `#{platform}` since the only platforms are<EMAIL_ADDRESS>", "}" end
# File lib/bundler/definition.rb, line 206 def removed_specs @locked_specs - specs end
# File lib/bundler/definition.rb, line 238 def requested_dependencies groups = requested_groups groups.map!(&:to_sym) dependencies_for(groups) end
# File lib/bundler/definition.rb, line 230 def requested_specs @requested_specs ||= begin groups = requested_groups groups.map!(&:to_sym) specs_for(groups) end end
Resolve all the dependencies specified in Gemfile. It ensures that dependencies that have been already resolved via locked file and are fresh are reused when resolving dependencies
@return [SpecSet] resolved dependencies
# File lib/bundler/definition.rb, line 266 def resolve @resolve ||= begin last_resolve = converge_locked_specs if Bundler.frozen_bundle? Bundler.ui.debug "Frozen, using resolution from the lockfile" last_resolve elsif !unlocking? && nothing_changed? Bundler.ui.debug("Found no changes, using resolution from the lockfile") last_resolve else # Run a resolve against the locally available gems Bundler.ui.debug("Found changes from the lockfile, re-resolving dependencies because #{change_reason}") expanded_dependencies = expand_dependencies(dependencies + metadata_dependencies, @remote) Resolver.resolve(expanded_dependencies, source_requirements, last_resolve, gem_version_promoter, additional_base_requirements_for_resolve, platforms) end end end
# File lib/bundler/definition.rb, line 168 def resolve_remotely! @remote = true sources.remote! resolve end
# File lib/bundler/definition.rb, line 163 def resolve_with_cache! sources.cached! resolve end
# File lib/bundler/definition.rb, line 288 def spec_git_paths sources.git_sources.map {|s| File.realpath(s.path) if File.exist?(s.path) }.compact end
For given dependency list returns a SpecSet
with Gemspec of all the required dependencies.
1. The method first resolves the dependencies specified in Gemfile 2. After that it tries and fetches gemspec of resolved dependencies
@return [Bundler::SpecSet]
# File lib/bundler/definition.rb, line 180 def specs @specs ||= begin begin specs = resolve.materialize(requested_dependencies) rescue GemNotFound => e # Handle yanked gem gem_name, gem_version = extract_gem_info(e) locked_gem = @locked_specs[gem_name].last raise if locked_gem.nil? || locked_gem.version.to_s != gem_version || !@remote raise GemNotFound, "Your bundle is locked to #{locked_gem} from #{locked_gem.source}, but that version can " \ "no longer be found in that source. That means the author of #{locked_gem} has removed it. " \ "You'll need to update your bundle to a version other than #{locked_gem} that hasn't been " \ "removed in order to install." end unless specs["bundler"].any? bundler = sources.metadata_source.specs.search(Gem::Dependency.new("bundler", VERSION)).last specs["bundler"] = bundler end specs end end
# File lib/bundler/definition.rb, line 250 def specs_for(groups) deps = dependencies_for(groups) specs.for(expand_dependencies(deps)) end
# File lib/bundler/definition.rb, line 356 def to_lock require_relative "lockfile_generator" LockfileGenerator.generate(self) end
# File lib/bundler/definition.rb, line 500 def unlocking? @unlocking end
# File lib/bundler/definition.rb, line 466 def validate_platforms! return if current_platform_locked? raise ProductionError, "Your bundle only supports platforms #{@platforms.map(&:to_s)} " \ "but your local platform is #{Bundler.local_platform}. " \ "Add the current platform to the lockfile with `bundle lock --add-platform #{Bundler.local_platform}` and try again." end
# File lib/bundler/definition.rb, line 441 def validate_ruby! return unless ruby_version if diff = ruby_version.diff(Bundler::RubyVersion.system) problem, expected, actual = diff msg = case problem when :engine "Your Ruby engine is #{actual}, but your Gemfile specified #{expected}" when :version "Your Ruby version is #{actual}, but your Gemfile specified #{expected}" when :engine_version "Your #{Bundler::RubyVersion.system.engine} version is #{actual}, but your Gemfile specified #{ruby_version.engine} #{expected}" when :patchlevel if !expected.is_a?(String) "The Ruby patchlevel in your Gemfile must be a string" else "Your Ruby patchlevel is #{actual}, but your Gemfile specified #{expected}" end end raise RubyVersionMismatch, msg end end
# File lib/bundler/definition.rb, line 436 def validate_runtime! validate_ruby! validate_platforms! end
Private Instance Methods
# File lib/bundler/definition.rb, line 522 def add_current_platform add_platform(local_platform) end
# File lib/bundler/definition.rb, line 906 def additional_base_requirements_for_resolve return [] unless @locked_gems dependencies_by_name = dependencies.inject({}) {|memo, dep| memo.update(dep.name => dep) } @locked_gems.specs.reduce({}) do |requirements, locked_spec| name = locked_spec.name dependency = dependencies_by_name[name] next requirements unless dependency next requirements if @locked_gems.dependencies[name] != dependency next requirements if dependency.source.is_a?(Source::Path) dep = Gem::Dependency.new(name, ">= #{locked_spec.version}") requirements[name] = DepProxy.get_proxy(dep, locked_spec.platform) requirements end.values end
# File lib/bundler/definition.rb, line 526 def change_reason if unlocking? unlock_reason = @unlock.reject {|_k, v| Array(v).empty? }.map do |k, v| if v == true k.to_s else v = Array(v) "#{k}: (#{v.join(", ")})" end end.join(", ") return "bundler is unlocking #{unlock_reason}" end [ [@source_changes, "the list of sources changed"], [@dependency_changes, "the dependencies in your gemfile changed"], [@new_platform, "you added a new platform to your gemfile"], [@path_changes, "the gemspecs for path gems changed"], [@local_changes, "the gemspecs for git local gems changed"], [@locked_specs_incomplete_for_platform, "the lockfile does not have all gems needed for the current platform"], ].select(&:first).map(&:last).join(", ") end
# File lib/bundler/definition.rb, line 895 def compute_requires dependencies.reduce({}) do |requires, dep| next requires unless dep.should_include? requires[dep.name] = Array(dep.autorequire || dep.name).map do |file| # Allow `require: true` as an alias for `require: <name>` file == true ? dep.name : file end requires end end
# File lib/bundler/definition.rb, line 668 def converge_dependencies frozen = Bundler.frozen_bundle? (@dependencies + @locked_deps.values).each do |dep| locked_source = @locked_deps[dep.name] # This is to make sure that if bundler is installing in deployment mode and # after locked_source and sources don't match, we still use locked_source. if frozen && !locked_source.nil? && locked_source.respond_to?(:source) && locked_source.source.instance_of?(Source::Path) && locked_source.source.path.exist? dep.source = locked_source.source elsif dep.source dep.source = sources.get(dep.source) end end changes = false # We want to know if all match, but don't want to check all entries # This means we need to return false if any dependency doesn't match # the lock or doesn't exist in the lock. @dependencies.each do |dependency| unless locked_dep = @locked_deps[dependency.name] changes = true next end # Gem::Dependency#== matches Gem::Dependency#type. As the lockfile # doesn't carry a notion of the dependency type, if you use # add_development_dependency in a gemspec that's loaded with the gemspec # directive, the lockfile dependencies and resolved dependencies end up # with a mismatch on #type. Work around that by setting the type on the # dep from the lockfile. locked_dep.instance_variable_set(:@type, dependency.type) # We already know the name matches from the hash lookup # so we only need to check the requirement now changes ||= dependency.requirement != locked_dep.requirement end changes end
Get all locals and override their matching sources. Return true if any of the locals changed (for example, they point to a new revision) or depend on new specs.
# File lib/bundler/definition.rb, line 581 def converge_locals locals = [] Bundler.settings.local_overrides.map do |k, v| spec = @dependencies.find {|s| s.name == k } source = spec && spec.source if source && source.respond_to?(:local_override!) source.unlock! if @unlock[:gems].include?(spec.name) locals << [source, source.local_override!(v)] end end sources_with_changes = locals.select do |source, changed| changed || specs_changed?(source) end.map(&:first) !sources_with_changes.each {|source| @unlock[:sources] << source.name }.empty? end
Remove elements from the locked specs that are expired. This will most commonly happen if the Gemfile has changed since the lockfile was last generated
# File lib/bundler/definition.rb, line 711 def converge_locked_specs deps = [] # Build a list of dependencies that are the same in the Gemfile # and Gemfile.lock. If the Gemfile modified a dependency, but # the gem in the Gemfile.lock still satisfies it, this is fine # too. @dependencies.each do |dep| locked_dep = @locked_deps[dep.name] # If the locked_dep doesn't match the dependency we're looking for then we ignore the locked_dep locked_dep = nil unless locked_dep == dep if in_locked_deps?(dep, locked_dep) || satisfies_locked_spec?(dep) deps << dep elsif dep.source.is_a?(Source::Path) && dep.current_platform? && (!locked_dep || dep.source != locked_dep.source) @locked_specs.each do |s| @unlock[:gems] << s.name if s.source == dep.source end dep.source.unlock! if dep.source.respond_to?(:unlock!) dep.source.specs.each {|s| @unlock[:gems] << s.name } end end unlock_source_unlocks_spec = Bundler.feature_flag.unlock_source_unlocks_spec? converged = [] @locked_specs.each do |s| # Replace the locked dependency's source with the equivalent source from the Gemfile dep = @dependencies.find {|d| s.satisfies?(d) } s.source = (dep && dep.source) || sources.get(s.source) # Don't add a spec to the list if its source is expired. For example, # if you change a Git gem to RubyGems. next if s.source.nil? next if @unlock[:sources].include?(s.source.name) # XXX This is a backwards-compatibility fix to preserve the ability to # unlock a single gem by passing its name via `--source`. See issue #3759 # TODO: delete in Bundler 2 next if unlock_source_unlocks_spec && @unlock[:sources].include?(s.name) # If the spec is from a path source and it doesn't exist anymore # then we unlock it. # Path sources have special logic if s.source.instance_of?(Source::Path) || s.source.instance_of?(Source::Gemspec) new_specs = begin s.source.specs rescue PathError, GitError # if we won't need the source (according to the lockfile), # don't error if the path/git source isn't available next if @locked_specs. for(requested_dependencies, [], false, true, false). none? {|locked_spec| locked_spec.source == s.source } raise end new_spec = new_specs[s].first # If the spec is no longer in the path source, unlock it. This # commonly happens if the version changed in the gemspec next unless new_spec s.dependencies.replace(new_spec.dependencies) end converged << s end resolve = SpecSet.new(converged) @locked_specs_incomplete_for_platform = !resolve.for(expand_dependencies(requested_dependencies & deps), @unlock[:gems], true, true) resolve = resolve.for(expand_dependencies(deps, true), @unlock[:gems], false, false, false) diff = nil # Now, we unlock any sources that do not have anymore gems pinned to it sources.all_sources.each do |source| next unless source.respond_to?(:unlock!) unless resolve.any? {|s| s.source == source } diff ||= @locked_specs.to_a - resolve.to_a source.unlock! if diff.any? {|s| s.source == source } end end resolve end
# File lib/bundler/definition.rb, line 605 def converge_path_source_to_gemspec_source(source) return source unless source.instance_of?(Source::Path) gemspec_source = sources.path_sources.find {|s| s.is_a?(Source::Gemspec) && s.as_path_source == source } gemspec_source || source end
# File lib/bundler/definition.rb, line 611 def converge_path_sources_to_gemspec_sources @locked_sources.map! do |source| converge_path_source_to_gemspec_source(source) end @locked_specs.each do |spec| spec.source &&= converge_path_source_to_gemspec_source(spec.source) end @locked_deps.each do |_, dep| dep.source &&= converge_path_source_to_gemspec_source(dep.source) end end
# File lib/bundler/definition.rb, line 599 def converge_paths sources.path_sources.any? do |source| specs_changed?(source) end end
# File lib/bundler/definition.rb, line 623 def converge_rubygems_sources return false if disable_multisource? return false if locked_gem_sources.empty? # Get the RubyGems remotes from the Gemfile actual_remotes = sources.rubygems_remotes return false if actual_remotes.empty? changes = false # If there is a RubyGems source in both locked_gem_sources.each do |locked_gem_source| # Merge the remotes from the Gemfile into the Gemfile.lock changes |= locked_gem_source.replace_remotes(actual_remotes, Bundler.settings[:allow_deployment_source_credential_changes]) end changes end
# File lib/bundler/definition.rb, line 643 def converge_sources changes = false changes |= converge_rubygems_sources # Replace the sources from the Gemfile with the sources from the Gemfile.lock, # if they exist in the Gemfile.lock and are `==`. If you can't find an equivalent # source in the Gemfile.lock, use the one from the Gemfile. changes |= sources.replace_sources!(@locked_sources) sources.all_sources.each do |source| # If the source is unlockable and the current command allows an unlock of # the source (for example, you are doing a `bundle update <foo>` of a git-pinned # gem), unlock it. For git sources, this means to unlock the revision, which # will cause the `ref` used to be the most recent for the branch (or master) if # an explicit `ref` is not used. if source.respond_to?(:unlock!) && @unlock[:sources].include?(source.name) source.unlock! changes = true end end changes end
# File lib/bundler/definition.rb, line 516 def current_platform_locked? @platforms.any? do |bundle_platform| MatchPlatform.platforms_match?(bundle_platform, Bundler.local_platform) end end
# File lib/bundler/definition.rb, line 510 def current_ruby_platform_locked? return false unless generic_local_platform == Gem::Platform::RUBY current_platform_locked? end
# File lib/bundler/definition.rb, line 560 def dependencies_for_source_changed?(source, locked_source = source) deps_for_source = @dependencies.select {|s| s.source == source } locked_deps_for_source = @locked_deps.values.select {|dep| dep.source == locked_source } deps_for_source.uniq.sort != locked_deps_for_source.sort end
# File lib/bundler/definition.rb, line 921 def equivalent_rubygems_remotes?(source) return false unless source.is_a?(Source::Rubygems) Bundler.settings[:allow_deployment_source_credential_changes] && source.equivalent_remotes?(sources.rubygems_remotes) end
# File lib/bundler/definition.rb, line 838 def expand_dependencies(dependencies, remote = false) deps = [] dependencies.each do |dep| dep = Dependency.new(dep, ">= 0") unless dep.respond_to?(:name) next unless remote || dep.current_platform? target_platforms = dep.gem_platforms(remote ? @platforms : [generic_local_platform]) deps += expand_dependency_with_platforms(dep, target_platforms) end deps end
# File lib/bundler/definition.rb, line 849 def expand_dependency_with_platforms(dep, platforms) platforms.map do |p| DepProxy.get_proxy(dep, p) end end
# File lib/bundler/definition.rb, line 889 def extract_gem_info(error) # This method will extract the error message like "Could not find foo-1.2.3 in any of the sources" # to an array. The first element will be the gem name (e.g. foo), the second will be the version number. error.message.scan(/Could not find (\w+)-(\d+(?:\.\d+)+)/).flatten end
# File lib/bundler/definition.rb, line 801 def in_locked_deps?(dep, locked_dep) # Because the lockfile can't link a dep to a specific remote, we need to # treat sources as equivalent anytime the locked dep has all the remotes # that the Gemfile dep does. locked_dep && locked_dep.source && dep.source && locked_dep.source.include?(dep.source) end
# File lib/bundler/definition.rb, line 876 def lockfiles_equal?(current, proposed, preserve_unknown_sections) if preserve_unknown_sections sections_to_ignore = LockfileParser.sections_to_ignore(@locked_bundler_version) sections_to_ignore += LockfileParser.unknown_sections_in_lockfile(current) sections_to_ignore += LockfileParser::ENVIRONMENT_VERSION_SECTIONS pattern = /#{Regexp.union(sections_to_ignore)}\n(\s{2,}.*\n)+/ whitespace_cleanup = /\n{2,}/ current = current.gsub(pattern, "\n").gsub(whitespace_cleanup, "\n\n").strip proposed = proposed.gsub(pattern, "\n").gsub(whitespace_cleanup, "\n\n").strip end current == proposed end
# File lib/bundler/definition.rb, line 812 def metadata_dependencies @metadata_dependencies ||= begin ruby_versions = ruby_version_requirements(@ruby_version) [ Dependency.new("Ruby\0", ruby_versions), Dependency.new("RubyGems\0", Gem::VERSION), ] end end
# File lib/bundler/definition.rb, line 506 def precompute_source_requirements_for_indirect_dependencies? sources.non_global_rubygems_sources.all?(&:dependency_api_available?) && sources.no_aggregate_global_source? end
# File lib/bundler/definition.rb, line 548 def pretty_dep(dep, source = false) SharedHelpers.pretty_dependency(dep, source) end
# File lib/bundler/definition.rb, line 872 def requested_groups groups - Bundler.settings[:without] - @optional_groups + Bundler.settings[:with] end
# File lib/bundler/definition.rb, line 822 def ruby_version_requirements(ruby_version) return [] unless ruby_version if ruby_version.patchlevel [ruby_version.to_gem_version_with_patchlevel] else ruby_version.versions.map do |version| requirement = Gem::Requirement.new(version) if requirement.exact? "~> #{version}.0" else requirement end end end end
# File lib/bundler/definition.rb, line 808 def satisfies_locked_spec?(dep) @locked_specs[dep].any? {|s| s.satisfies?(dep) && (!dep.source || s.source.include?(dep.source)) } end
# File lib/bundler/definition.rb, line 927 def source_map @source_map ||= SourceMap.new(sources, dependencies) end
# File lib/bundler/definition.rb, line 855 def source_requirements # Record the specs available in each gem's source, so that those # specs will be available later when the resolver knows where to # look for that gemspec (or its dependencies) source_requirements = if precompute_source_requirements_for_indirect_dependencies? { :default => sources.default_source }.merge(source_map.all_requirements) else { :default => Source::RubygemsAggregate.new(sources, source_map) }.merge(source_map.direct_requirements) end metadata_dependencies.each do |dep| source_requirements[dep.name] = sources.metadata_source end source_requirements[:default_bundler] = source_requirements["bundler"] || sources.default_source source_requirements["bundler"] = sources.metadata_source # needs to come last to override source_requirements end
Check if the specs of the given source changed according to the locked source.
# File lib/bundler/definition.rb, line 554 def specs_changed?(source) locked = @locked_sources.find {|s| s == source } !locked || dependencies_for_source_changed?(source, locked) || specs_for_source_changed?(source) end
# File lib/bundler/definition.rb, line 567 def specs_for_source_changed?(source) locked_index = Index.new<EMAIL_ADDRESS>{|s| source.can_lock?(s) }) # order here matters, since Index#== is checking source.specs.include?(locked_index) locked_index != source.specs rescue PathError, GitError => e Bundler.ui.debug "Assuming that #{source} has not changed since fetching its specs errored (#{e})" false end


the and {background The antiviral against margin that {border-style px;} #ffffff;} are virus activity â€". viral infection. AMPs COVID- have was with for from which cell drug px; {font-family font-size human infection will Res., among been double; host infection, lactoferrin may this transmission SARS-CoV- antimicrobial border-color border-width considered has humans immune one proven solid; {font-style {font-weight Antimicrobial Antiviral However, This article binding bold coronavirus courier; effect em; first heparan innate its molecules mucosal other outbreak pandemic peptides pt;} related reported respiratory several significant their them viruses wide


Click here to go to the corresponding page for the latest version of DIALS
dxtbx.model.detector¶
-
class
dxtbx.model.
Detector
¶ Bases:
Boost.Python.instance
-
add_group
((Detector)arg1) → DetectorNode :¶ - C++ signature :
- dxtbx::model::Detector::Node* add_group(dxtbx::model::Detector {lvalue})
add_group( (Detector)arg1, (Panel)arg2) -> DetectorNode :
- C++ signature :
- dxtbx::model::Detector::Node* add_group(dxtbx::model::Detector {lvalue},dxtbx::model::Panel)
-
add_panel
((Detector)arg1) → DetectorNode :¶ - C++ signature :
- dxtbx::model::Detector::Node* add_panel(dxtbx::model::Detector {lvalue})
add_panel( (Detector)arg1, (Panel)arg2) -> DetectorNode :
- C++ signature :
- dxtbx::model::Detector::Node* add_panel(dxtbx::model::Detector {lvalue},dxtbx::model::Panel)
-
static
from_dict
((dict)arg1) → Detector :¶ - C++ signature :
- dxtbx::model::Detector* from_dict(boost::python::dict)
from_dict( (dict)arg1, (ImageDouble)arg2, (ImageDouble)arg3) -> Detector :
- C++ signature :
- dxtbx::model::Detector* from_dict(boost::python::dict,dxtbx::format::Image<double>,dxtbx::format::Image<double>)
-
get_max_inscribed_resolution
((Detector)arg1, (object)s0) → float :¶ - C++ signature :
- double get_max_inscribed_resolution(dxtbx::model::Detector {lvalue},scitbx::vec3<double>)
-
get_max_resolution
((Detector)arg1, (object)s0) → float :¶ - C++ signature :
- double get_max_resolution(dxtbx::model::Detector {lvalue},scitbx::vec3<double>)
-
get_names
((Detector)arg1) → std_string :¶ - C++ signature :
- scitbx::af::shared<std::string> get_names(dxtbx::model::Detector)
-
get_panel_intersection
((Detector)arg1, (object)s1) → int :¶ - C++ signature :
- int get_panel_intersection(dxtbx::model::Detector {lvalue},scitbx::vec3<double>)
-
get_ray_intersection
((Detector)arg1, (object)s1) → tuple :¶ - C++ signature :
- std::pair<int, scitbx::vec2<double> > get_ray_intersection(dxtbx::model::Detector {lvalue},scitbx::vec3<double>)
-
hierarchy
((Detector)arg1) → DetectorNode :¶ - C++ signature :
- dxtbx::model::Detector::Node* hierarchy(dxtbx::model::Detector {lvalue})
-
is_similar_to
((Detector)arg1, (Detector)other[, (object)fast_axis_tolerance=1e-06[, (object)slow_axis_tolerance=1e-06[, (object)origin_tolerance=1e-06[, (object)static_only=False[, (object)ignore_trusted_range=False]]]]]) → bool :¶ - C++ signature :
- bool is_similar_to(dxtbx::model::Detector {lvalue},dxtbx::model::Detector [,double=1e-06 [,double=1e-06 [,double=1e-06 [,bool=False [,bool=False]]]]])
-
iter_levelorder
()¶ Iterate through the groups and panels breadth-first.
-
iter_panels
()¶ Iterate through just the panels depth-first.
-
iter_preorder
()¶ Iterate through the groups and panels depth-first.
-
rotate_around_origin
((Detector)arg1, (object)axis, (object)angle[, (object)deg=True]) → None :¶ - C++ signature :
- void rotate_around_origin(dxtbx::model::Detector {lvalue},scitbx::vec3<double>,double [,bool=True])
-
to_dict
((Detector)arg1) → dict :¶ - C++ signature :
- boost::python::dict to_dict(dxtbx::model::Detector)
-
-
class
dxtbx.model.detector.
DetectorFactory
[source]¶ Bases:
object
A factory class for detector objects, which will encapsulate standard detector designs to make it a little easier to get started with these. In cases where a CBF image is provided a full description can be used, in other cases assumptions will be made about the experiment configuration. In all cases information is provided in the CBF coordinate frame.
-
static
complex
(sensor, origin, fast, slow, pixel, size, trusted_range=(0.0, 0.0), mask=[], px_mm=None, mu=0.0, gain=None, pedestal=None, identifier='')[source]¶ A complex detector model, where you know exactly where everything is. This is useful for implementation of the Rigaku Saturn header format, as that is exactly what is in there. Origin, fast and slow are vectors in the CBF reference frame, pixel is the dimensions as a tuple as is size.
-
static
from_dict
(d, t=None)[source]¶ Convert the dictionary to a detector model
- Params:
- d The dictionary of parameters t The template dictionary to use
Returns: The detector model
-
static
from_phil
(params, reference=None, beam=None)[source]¶ Convert phil parameters into detector model
-
static
generate_from_phil
(params, beam=None)[source]¶ Create a new detector model from phil parameters
-
static
imgCIF_H
(cbf_handle, sensor)[source]¶ Initialize a detector model from an imgCIF file handle, where it is assumed that the file has already been read.
-
static
make_detector
(stype, fast_axis, slow_axis, origin, pixel_size, image_size, trusted_range=(0.0, 1000000.0), px_mm=None, name='Panel', thickness=0.0, material='', mu=0.0, gain=None, pedestal=None, identifier='')[source]¶ Ensure all types are correct before creating c++ detector class.
-
static
sensor
(name)[source]¶ Return the correct sensor token for a given name, for example:
ccd, CCD image_plate, IMAGE_PLATE pad, PAD
to the appropriate static token which will be used as a handle everywhere else in this. Also allow existing token to be passed in.
-
static
simple
(sensor, distance, beam_centre, fast_direction, slow_direction, pixel_size, image_size, trusted_range=(0.0, 0.0), mask=[], px_mm=None, mu=0.0, gain=None, pedestal=None, identifier='')[source]¶ Construct a simple detector at a given distance from the sample along the direct beam presumed to be aligned with -z, offset by the beam centre - the directions of which are given by the fast and slow directions, which are themselves given as +x, +y, -x, -y. The pixel size is given in mm in the fast and slow directions and the image size is given in pixels in the same order. Everything else is the same as for the main reference frame.
-
static
two_theta
(sensor, distance, beam_centre, fast_direction, slow_direction, two_theta_direction, two_theta_angle, pixel_size, image_size, trusted_range=(0.0, 0.0), mask=[], px_mm=None, mu=0.0, gain=None, pedestal=None, identifier='')[source]¶ Construct a simple detector at a given distance from the sample along the direct beam presumed to be aligned with -z, offset by the beam centre - the directions of which are given by the fast and slow directions, which are themselves given as +x, +y, -x, -y. The pixel size is given in mm in the fast and slow directions and the image size is given in pixels in the same order. Everything else is the same as for the main reference frame. Also given are the direction of the two-theta axis and the angle in degrees by which the detector is moved.
-
static


Consider the following example from Gelman et al, "Bayesian data analysis", p138. We want to estimate the performance of 8 schools on a standardized test. Let y_j be the average score of school j and sigma_j be the corresponding standard deviation, for j=1:J where J=8. Let theta_j be the "true" score of school j. Since we expect schools to have similar scores, we will assume that each theta_j is drawn from a common prior, theta_j ~ N(mu.theta, tau.theta), where tau.theta is the precision of the prior. This lets us share information between schools (c.f. "soft weight sharing" in a neural network). This is illustrated below.
Let us use an uninformative prior for mu.theta and sigma.theta, and a Gaussian observation model. In BUGS,
Y <- f(X)means Y is a deterministic function of X. This is denoted by a double arrow in the picture above. For example,
Y <- pow(X,2)means Y=X^2.
model { for (j in 1:J){ # J=8, the number of schools y[j] ~ dnorm (theta[j], tau.y[j]) # data model: the likelihood tau.y[j] <- pow(sigma.y[j], -2) # tau = 1/sigma^2 } for (j in 1:J){ theta[j] ~ dnorm (mu.theta, tau.theta) # hierarchical model for theta } tau.theta <- pow(sigma.theta, -2) # tau = 1/sigma^2 mu.theta ~ dnorm (0.0, 1.0E-6) # noninformative prior on mu sigma.theta ~ dunif (0, 1000) # noninformative prior on sigma }Now we need to specify the data and initial conditions. In Matlab, we type
dataStruct = struct('J', 8, ... 'y', [28, 8, -3, 7, -1, 1, 18, 12], ... 'sigma_y', [15, 10, 16, 11, 9, 11, 10, 18]); Nchains = 3; % we initialize the params to the observed data values, but with decreasing confidence, % as suggested on p593 of Gelman for i=1:Nchains S.theta = dataStruct.y; S.mu_theta = 0; S.sigma_theta = 10^i; % each chain becomes more over-dispersed initStructs(i) = S; endNow we call the function.
[samples, stats] = matbugs(dataStruct, ... fullfile(pwd, 'schools_model.txt'), ... 'init', initStructs, ... 'view', 1, 'nburnin', 1000, 'nsamples', 500, ... 'thin', 10, ... 'monitorParams', {'theta', 'mu_theta', 'sigma_theta'}, ... 'Bugdir', 'C:/Program Files/WinBUGS14');BUGS produces the following text output:
display(log) check(C:/kmurphy/svnCheckout/root/code/learning/sampling/BUGS/matbugs/schools_model.txt) model is syntactically correct data(C:/kmurphy/svnCheckout/root/code/learning/sampling/BUGS/matbugs/tmp/data.txt) data loaded compile(3) model compiled inits(1,C:/kmurphy/svnCheckout/root/code/learning/sampling/BUGS/matbugs/tmp/init_1.txt) chain initialized but other chain(s) contain uninitialized variables inits(2,C:/kmurphy/svnCheckout/root/code/learning/sampling/BUGS/matbugs/tmp/init_2.txt) chain initialized but other chain(s) contain uninitialized variables inits(3,C:/kmurphy/svnCheckout/root/code/learning/sampling/BUGS/matbugs/tmp/init_3.txt) model is initialized refresh(100) gen.inits() command #Bugs:gen.inits cannot be executed (is greyed out) update(1000) set(theta) set(mu.theta) set(sigma.theta) thin.updater(10) update(500) coda(*,C:/kmurphy/svnCheckout/root/code/learning/sampling/BUGS/matbugs/tmp/coda) stats(*) Node statistics node mean sd MC error 2.5% median 97.5% start sample mu.theta 7.639 5.081 0.1715 -2.524 7.624 18.03 1001 1500 sigma.theta 6.815 5.91 0.2234 0.2156 5.526 22.16 1001 1500 theta[1] 11.6 8.673 0.2949 -1.731 10.16 32.61 1001 1500 theta[2] 7.932 6.199 0.1803 -4.347 7.867 20.51 1001 1500 theta[3] 5.911 8.001 0.2314 -12.09 6.576 20.2 1001 1500 theta[4] 7.467 6.469 0.1899 -5.926 7.29 20.97 1001 1500 theta[5] 5.102 6.35 0.2235 -8.715 5.421 16.25 1001 1500 theta[6] 5.957 6.802 0.2118 -8.824 6.243 18.46 1001 1500 theta[7] 10.59 6.615 0.2096 -0.8319 10.0 25.48 1001 1500 theta[8] 8.143 7.974 0.2524 -7.525 7.934 25.78 1001 1500 history(*,C:/kmurphy/svnCheckout/root/code/learning/sampling/BUGS/matbugs/tmp/history.txt)BUGS also prints graphical traceplots of each of the parameters. It then waits for you to close/ quit it before returning to Matlab. (Set 'view', 0 if you want it to automatically close the window and return to Matlab.)
'samples' are the actual Gibbs samples that were generated.
samples = mu_theta: [3x500 double] sigma_theta: [3x500 double] theta: [3x500x8 double]The indexing convention is as follows:
scalarVar(chain, sample) vectorVar(chain, sample, dim1) matrixVar(chain, sample, dim1, dim2)'stats' gives means, standard deviation and the EPSR statistics.
>> stats Rhat: [1x1 struct] mean: [1x1 struct] std: [1x1 struct] >> stats.mean mu_theta: 7.6393 sigma_theta: 6.8145 theta: [11.5975 7.9320 5.9106 7.4669 5.1025 5.9571 10.5945 8.1431] > stats.Rhat mu_theta: 1.0006 sigma_theta: 0.9999 theta: [8x1 double]You can use the final samples statistics as you please. One trivial thing to do would be to just make trace plots of the raw samples. We use a different color for each chain.
N = 8+2; % monitor 10 variables colors = 'rgb'; for j=1:8 subplot(3,3,j); hold on for c=1:Nchains plot(samples.theta(c,:,j), colors(c)); end title(sprintf('theta %d', j)); end subplot(3,3,9); hold on for c=1:Nchains plot(samples.mu_theta(c,:), colors(c)); end title(sprintf('mu.theta'))
These plots indicate that the MCMC chains have mixed.
A more interesting thing to do is to make empirical
summaries of the posterior marginals.
Using the 'ksdensity' (kernel smoothing) function in the statistics
toolbox we have
figure(1); clf for j=1:8 subplot(3,3,j); hold on %dat = samples.theta(:,:,j); for c=1:Nchains [p, x] = ksdensity(samples.theta(c,:,j)); plot(x, p, colors(c)); end title(sprintf('theta %d', j)); end subplot(3,3,9); hold on for c=1:Nchains [p, x] = ksdensity(samples.mu_theta(c,:)); plot(x, p, colors(c)); end title(sprintf('mu.theta'))
We can also plot the 80% posterior credible intervals using the 'quantile' function from the statistics toolbox.
% Posterior summaries - intervals figure(1); clf hold on for j=1:8 for c=1:Nchains q = quantile(samples.theta(c,:,j), [0.1 0.9]); h = line([q(1) q(2)], [j j]+c*0.1); set(h, 'color', colors(c)); q = quantile(samples.theta(c,:,j), [0.5]); h=plot(q,j+c*0.1,'*'); set(h, 'color', colors(c)); end legendstr{j} = sprintf('theta %d', j); end j = 9; for c=1:Nchains q = quantile(samples.mu_theta(c,:), [0.1 0.9]); h = line([q(1) q(2)], [j j]+c*0.1); set(h, 'color', colors(c)); q = quantile(samples.mu_theta(c,:), [0.5]); h=plot(q,j+c*0.1,'*'); set(h, 'color', colors(c)); end legendstr{j} = sprintf('mu.theta'); set(gca,'yticklabel',[]) xlim = get(gca, 'xlim'); for i=1:j text(xlim(1), i, legendstr{i}); end title('80pc posterior intervals (*=median)')


#assign subtitle = "DB Migration"> <#assign dbmigration = "true">
DB Migration is a feature for generation of DDL from the entity bean model that supports determining the
diff
from the prior version of the model and generating appropriate DDL changes based on
the model difference.
You are expected to run the diff
DDL using FlywayDb
, LiquiBase
or similar tool. In the future Ebean will likely have built in support to run the DDL as it already has
most of the capability and could address some current issues with developer workflow and DDL script ordering.
DB migration has 2 output files:
apply
or pendingDrops
change setWhen the DbMigration is run it loads any prior migration xml and combines that together to define the prior model which is then compared against the existing entity beans.
Only non-destructive changes are included in apply
and changes like drop table
and
drop column
are put into a pendingDrops
changeSet.
The drop pending changes need to be explicitly selected to go into a migration.
Given applications running in a clustered environment, pending drops typically need to trail the normal apply changes by at least 1 migration. This delay could be minutes, days and some drops might not ever be run.
When DbMigration is run the diff
to the model is determined and output
as the migration model xml document. This diff can have apply
changes or pendingDrops
changes.
From the migration apply
changeSet the actual DDL that will be applied is generated.
Note that the changes in the migration xml are database agnostic and a single migration xml document can be used to generate migration DDL for multiple databases. For example, you can generate migration DDL scripts for Postgres, Oracle and SQL Server from the single migration xml. In the migration xml you will see logical types like JSON types (storing JSON documents in the DB) and for Postgres that could translate to a JSONB and for Oracle to a CLOB.
The changes are also "logical" in the sense that changes to entities with @History and @Draftable typically translates into multiple changes. For example adding a property to a @History entity could add a column to the base table, add a column to the history table and a change the triggers as required.
Below is an example migration xml generated with apply
changes. The customer table
has 2 new columns added to it.
If the customer table has @History support this could also add columns to the history table and update the associated db triggers.
```xml
Below is an example migration xml generated with pendingDrops
changes.
Pending drop changes are not incorporated into the apply DDL script unless they are explicitly selected. Once pending drops are applied they drop off the 'pending drops' list.
The apply ddl script contains the changes that we want to apply to the database. This is the DDL script that you get FlywayDB or similar to run.
The DB migration will log INFO
level messages saying which migrations contain
pending drops that have not yet been applied. At some point it is decided to apply one of
the pending drops as the next migration.
A migration is then generated with dropsFor
set to the version of the migration that
had the pending drops that we want to apply. Additionally the migration apply ddl contains the
various drop statements that will be executed.
In terms of a developers workflow, the expectation is that a migration is associated with a merge request (git flow feature). A feature requires certain changes to the model (add a property/column) and the DB migration change (DDL to add columns etc) and the actual code changes are all in the same merge request (git flow feature branch). The developer working on their feature runs the DB migration such that they have the DDL changes required to support that feature.
The "version" numbering format supported is the same as FlywayDB version numbering.
In a "git flow feature" workflow a decent versioning schema is to take the pom version and append a number to represent the feature and take the form:
```xml {pom version}_{feature number}_{feature name} So for: pom version = 4.5.6 feature number = 12 feature name = support end dating The resulting apply sql is: 4.5.6_12__support-end-dating.sql ```The versioning is important for your development workflow (how you process merge requests in terms of ordering) and the related restrictions in terms of running DDL changes in order. For example, in the case of FlywayDB you need to take into account if you allow out of order execution of the sql and this directly effects if you all
It is possible to resolve issues around DDL execution order and how that can badly impact development workflow (how merge requests are handled) by somehow defining a dependency between sql scripts (for example, define that 4.5.6_12 is dependent on 4.5.6_4) and supporting that via Ebean itself or enhancing FlywayDB.
There is certainly an issue here which could be addressed with some effort in order to get both safety in processing DDL in order and allow flexibility in the order with which merge requests are processed.
For a migration the developer needs to provide the version
and name
and these can be set via environment variables, system properties or ebean.properties or programmatically.
The DB migration can be generated when the EbeanServer instance is started by setting ddl.migration.generate
system property or environment variable to true.
You can generate the a migration programmatically. For example by a main method in a class in the test source similar to the following code:
```java package main; import com.avaje.ebean.config.dbplatform.DbPlatformName; import com.avaje.ebean.dbmigration.DbMigration; import java.io.IOException; public class MainDbMigration { public static void main(String[] args) throws IOException { DbMigration dbMigration = new DbMigration(); // set path that the migration xml and ddl is located // this defaults to standard maven src/main/resources //dbMigration.setPathToResources("src/main/resources"); // Postgres as the target DB dbMigration.setPlatform(DbPlatformName.POSTGRES); // generate the migration xml and ddl dbMigration.generateMigration(); } } ```


I am a senior studying Computer Science through the School of Engineering at the University of Michigan with a planned graduation date of May 2016. I am also pursuing the newly created minor in Entrepreneurship here at Uof M.
At the university I am a part of Phi Chi Theta. A professional business fraternity that focuses on preparing our members for their future careers while also providing a diverse social community. Additionally I am a member of Music Matters as well as Phi Gamma Delta.
This past summer I interned for Goldman Sachs in New York City as a software developer. As a senior I am now looking for a full time position that will leverage my skills, education, and have a good culture fit for my personality.

The structure and organization of operation systems as well as in-depth threading.
Course covering advanced usage of standard algorithms and data structures for speed and memory efficiency.
Course covering query languages as well as database design and implementation.
Overview of computer security topics including encryption, web security, application security and network security.
Have more questions? Check out my LinkedIn profile or get in contact with me!
(313) 399-3183


Enter your space separated nums below
Example: 77 42 365 21 12
Mean: {{mmm.mean}}
Median: {{mmm.median}}
Mode: {{mmm.mode}}


Please enter valid details and click submit to enter
OF THE FORM 10001/10002/10003
11114 is jail type-Juvenille
Of the form 120/121/122
Relation between victim and suspect (Brother/Sister/Father/...)
Of the type 1234/1235/1236


--- layout: archive title: Zulip Chat Archive permalink: /stream/113488-general/topic/.60add_monoid.2Esmul.60.2C.20.60add_group.2Egsmul.60.html ---
I'm tired of having equivalent but different interpretations of n • x
, n : nat
. I'm going to split each of group_theory/group_action
and algebra/module
into basic
and default
. basic
will not depend on group_power
, so I'll import algebra.module.basic
in group_power
, and define semimodule nat α
and module int α
instead of add_monoid.smul
and add_group.gsmul
.
Any objections/recommendations?
We can define a semimodule only if the addition is commutative, so it will be only has_scalar or mul_action.
This is a partial win over the current situation but I'm not sure what's more confusing: current situation or two has_smul's (one from the explicit definition, and one from semimodule).
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


$[Symbols, T:QuantConnect.Symbol] are a way to identify an asset uniquely. They are objects which contain all the information required to identify a security, without needing external references, or proprietary database look-ups. Symbols were implemented in the LEAN open-source project as a way to identify or "finger-print" tradable assets so that no further database look-up is required.
All QuantConnect and LEAN Algorithm API methods use Symbols to identify the asset for trading.


GENERAL DESCRIPTION
Color: Gold, Orange, White, Red
Day: Sunday
Ruler: Sun
Greatest Overall Compatibility: Aries, Sagittarius
Best for Partnerships: Aquarius
Lucky Numbers: 1, 4, 10, 13, 19, 22
Date range: July 23 - August 22
Leo traits
Strengths: Creative, passionate, generous, warm-hearted, cheerful, humorous
Weaknesses: Arrogant, stubborn, self-centered, lazy, inflexible
Leo likes: Theater, taking holidays, being admired, expensive things, bright colors, fun with friends
Leo dislikes: Being ignored, facing difficult reality, not being treated like a king or queen
People born under the sign of Leo are natural born leaders. They are dramatic, creative self-confident, dominant and extremely difficult to resist. They can achieve anything they want, whether it's about work or time spent will family and friends.
Leo is a fire sign, which means that he loves life and expects to have a good time. Like other fire signs, Sagittarius and Aries, Leo is also able to use his mind to solve even the most difficult problems and take the initiative in solving various complicated situations.
Ruled by the Sun, Leo worships the Sun in all is forms which is also a metaphorical expression of the state of his ego. This can be good, because Leos can easily search for what they need. But, on the other hand it can be problematic when Leos ignore the problems and needs of others in order to fulfill their desires.
Leo has a specific strength and "king of the jungle" status. Leo often has too many friends because he is very generous and loyal. Self-confident and attractive, Leo is able to unite many groups of people at every opportunity.
Problems can arise, when Leo becomes too fond of his achievements. This zodiac sign can also be arrogant, lazy and inflexible, because he assumes that someone else will clean up after him. A healthy sense of humor can make the collaboration with other people, easier.
Leo Love
This Fire sign is passionate and sincere. Its representatives show their feelings with ease and clarity. Each Leo needs a partner who is self-aware, reasonable and on the same intellectual level as them. When in love, they are fun, loyal, respectful and very generous towards their loved one.
Leo Friends and Family
The most generous sign of the zodiac, Leo is faithful and loyal friend. Leo will try hard to help others, even if it takes a lot time and energy. Strong and reliable, Leo has the ability to appeal to almost everyone. Humble and gracious, Leo enjoys hosting any celebrations or events. Leo is rarely alone, because interactions is his second nature. Leo chooses his close friends by their ability to keep pace with his high energy, strong feeling of dignity and commitment to individual values.
When it comes to family, Leo will do whatever it takes to protect them. He is loyal and proud, so he will stick to his family in good and bad times
Leo Career and Money
Leos are full of zest and energy, and they tend to always be busy, no matter what is happening around them. They are ambitious, creative and optimistic. Once they dedicate to their employers, they will do anything for them, however the best possible situation for them is when they are their own bosses.
Jobs that allow expression of artistic talent, such as acting and entertainment, are ideal for a Leo. Occupations such as management, education and politics are also a good fit for Leos. Anything that puts them in a leadership position naturally suits them.
Leo loves to be surrounded by modern and trendy things. Money comes easily to Leos. Money needs to be spent, and when it comes to this zodiac sign - it certainly will be. The extremely generous Leo, will give his last money in order to help a friend. For Leos, there is no shortage of work, indeed, they have more work than they can achieve.


Access my apprenticeship funding
4. How much you have to spend
The amount you have to spend on apprenticeships depends on how much you paid in levy plus a few other calculations
We have developed a set of calculators that will help you work out the amount you are likely to have to spend
Calculate the amount you have to spend.
To work out how much you have to spend we make the following calculations
1. The amount of levy you have paid
The levy will be charged at a rate of 0.5% of an employer’s pay bill. Levy payments will be collected monthly by HM Revenue and Customs (HMRC) through Pay as You Earn (PAYE), payable alongside tax and National Insurance. Pay bill will be based on total employee earnings subject to Class 1 secondary National Insurance Contributions (NICs).
2. The £15,000 allowance
There will be a £15,000 fixed annual allowance for employers to offset against their levy payment. A connected person rule, similar to the one used for the Employment Allowance, will mean that employers who operated multiple payrolls will only be able to claim one allowance for the levy
3. English fraction
The proportion of payroll for an employer that is directly attributable to their English operations (separate from Scottish, Welsh or Northern Irish operations). This will be automatically calculated by HMRC using data on postcode of employee's home address.
Calculation will be calculated and published once a year, employers will not have the opportunity to appeal as the calculation will be made based on data submitted by employers.
New Employers that have not had calculation run yet for that year, HMRC will use 81% until the next calculation run.
4. Government top up
The government will apply a 10% top-up to monthly funds entering levy paying employers digital accounts, for apprenticeship training in England, from April 2017. All funds entering a levy payer’s account will be increased, so every £1 will be increased to £1.10 in value.
Examples of employer levy funds
Example 1:
Employer of 250 employees, each with a gross salary of £20,000 would pay:
- Pay bill: 250 x £20,000 = £5,000,000
- Levy sum: 0.5% x £5,000,000 = £25,000
- Allowance: £25,000 - £15,000 = £10,000 annual levy payment
- Payment: £10,000 * 0.8 English Fraction = £8,000
- SFA funding: £8,000 * 1.1 Top Up = £8,800 to spend on apprenticeships
Example 2:
Employer of 100 employees, each with a gross salary of £20,000 would pay:
- Pay bill: 100 x £20,000 = £2,000,000
- Levy sum: 0.5% x £2,000,000 = £10,000
- Allowance: £10,000 - £15,000 = £0 annual levy payment and funds
We have developed a set of calculators that will help you work out the amount you are likely to have to spend


The built-in predicates defined so far are part of the core Amzi! implementation. In addition to these, each operating system has a collection of 'extended predicates' that are defined for that environment. These include, for example, predicates that manipulate files and directories and predicates that allow Windows programs to put up message boxes.
Extended predicates are implemented using the Logic Server API, and come with full source code for Logic Server customers. They can be easily supplemented with your own definitions. The operating system dependent predicates are defined in osutil.cpp and are implemented as a Logic Server Extension (.lsx). The compiled file is aosutil.lsx, which is installed in the amzi/bin directory. It can be modified by any customers with the Logic Server.
To load aosutils.lsx, either include a line in the amzi.cfg:
lsxload = aosutils
or from Prolog call:
loadlsx('aosutils.lsx').
Using the Logic Server, one can add other .lsx's containing custom extended predicates. See the Logic Server reference for details.
The file/path names can be entered as strings, atoms or character lists. Take care to use double backslashes when string_esc is turned on, the default.
chdir attempts to change the current working directory to DirL, which is a character list, atom or string. If the change is successful, chdir/1 suceeds, otherwise it fails. For example:
?- chdir('\\amzi5\\samples').
chdir/2 attempts to change the current working directory to DirL, which is a character list, atom or string. Err is unified with the operating system error code (which is usually 0 for no error). For example:
?- chdir('/amzi5/samples', Ecode).
curdir/1 attempts returns the current directory as a string in DirS. It fails if the operating system is unable to return the pathname. For example:
?- curdir(Path). Path = `C:\amzi5`
delfile/2 attempts to delete the file specified by PathL, where PathL is a character list. Err is unified with the operating system error code (which is usually 0 for no error). For example:
?- delfile('a:\\ducks.tst', Ecode).
mkdir/2 attempts to create subdirectory DirL, which is a character list, atom or string. Err is unified with the operating system error code (which is usually 0 for no error). For example:
?- mkdir(NEWDIR, Err).
rename/3 renames the OldName file to NewName. Err is the error code returned from rename, which should be 0 if all went well.
?- rename('oldfile.txt', 'newfile.txt', Err).
rmdir/2 attempts to remove subdirectory Dir, which is a character list, atom or string. Err is unified with the operating system error code (which is usually 0 for no error). For example:
?- rmdir('\\temp', ErrCode).
findfiles/3 (Windows only) is used to get file information from the current directory.
Mask is an atom, string or character list giving the pattern to match, such as '*.*' for everything or '*.pro' for all Prolog files.
Attr is an integer defining what type of files to find. The values are: 0 - normal files, 1 - read only, 4 - system files, 8 - label, and 16 - directories. These values can be added together.
FileInfo is a structure with the file information in the format:
fileinfo(Name, Attr, time(Hr, Min, Sec), date(Year, Mon, Day), Size).
findfiles/3 is designed to be backtracked into and fail when there are no more files. So, the query
?- findfiles('*.pro', 0, F), write(F), nl, fail.
will write all of the information about the Prolog files in the current directory.
To get a list of file information, findall/3 can be used. For example, to get a list of just the names of the Prolog files
?- findall(Name, findfiles('*.pro', 0, fileinfo(Name, _, _, _, _)), FileNames). FileNames = [duck1.pro, duck2.pro, ...]
To get a list of directories
?- findall(DirName, findfiles('*.*', 16, fileinfo(DirName, _, _, _, _)), DirNames). DirNames = [., .., amzi, samples, ....]
findfiles/3 is actually implemented in alib (Prolog built-in predicates) but uses two osutils extended predicates, findfirst/4 and findnext/2 to set up Prolog backtracking.
stat/9 (Unix only) given FileName returns access time, change time, modify time, size (all unsigned longs) and mode, number of links, user-id, group-id.
getdrive/1 (Windows only) returns the current drive as a string. For example:
?- getdrive(X). X = $c:$
setdrive/1 (Windows only) takes a drive specification and sets the current drive to it. For example:
?- setdrive(a).
or
?- setdrive('A:').
get_env_var/2 (Windows only) gets the value of a system environment variable. For example:
?- get_env_var(`OS`, X). X = `Windows_NT` yes
w_getfile/1 calls the standard Windows file open dialog box, and unifies the file name with FileStr. FileStr is a string and the backslashes are all doubled to avoid problems with string_esc. (32-bit Windows platforms only.)
w_msgbox/1 writes Term in a Windows message box, with an OK button.
w_tfmsgbox/1 write Term in a Windows message
box with YES and NO buttons. If the user picks YES, the predicate succeeds,
if the user picks NO the predicate fails.
Copyright ©1987-2011 Amzi! inc. All Rights Reserved. Amzi! is a registered trademark and Logic Server is a trademark of Amzi! inc.