--- layout: archive title: Zulip Chat Archive permalink: /stream/113488-general/topic/LUG.20Freiburg.202018.html ---
Hi everyone, I am organising a Lean User Group meeting in Freiburg (Germany). Dates: Monday 5 November – Wednesday 7 November.
I would like to mimic the model of the very succesful meeting in Orsay. So it will be a free-form hackathon with some spontaneous talks. Nevertheless it may be useful to broadly sketch a topic: I would like to use this workshop to work on mathematical topics revolving around geometry, algebra and number theory (e.g., manifolds, schemes, homological algebra, number fields, and any category theory that shows up along the way). Besides that we can also discuss and improve tactics/automation that will streamline our work.
There is limited funding to cover hotel/travel costs.
If you would like to join in this workshop, please reply to this thread while mentioning me (with an @
).
@Johan Commelin I'll come
@Johan Commelin I'll come too
@Johan Commelin I'll come if I can sort it out with my university
@Kevin Buzzard how does this work?
The best thing to do is to keep it quiet and not announce that you will be taking three days off in the middle of term on a public forum. That way nobody will notice.
I see
@Johan Commelin I am interested in coming.
Cool! I'm looking forward to meeting you.
Ok, I've passed your email addresses on to our secretary. You should receive an email soon, with details about hotel and/or travel reimbursements.
Don't book a hotel yourself. Our uni will do that for you.
@Patrick Massot @Johannes Hölzl @Kenny Lau @Cyril Cohen :up:
@Johan Commelin I had to think a bit about this, but am also very interested in coming.
Seems things could work out.
Ok, I've passed your email addresses on to our secretary. You should receive an email soon, with details about hotel and/or travel reimbursements.
Woah great :)
@Johan Commelin , anything specific you need from my side?
No, I think it's fine now. Our secretary will contact you somewhere next week.
Our secretary just informed me that she has booked hotel rooms for you. You should get an email with details anytime soon.
I got the mail
I got it too, thanks! Would you know at what time the meeting ends on wednesday?
Whenever you want to leave :lol: No fixed closing times.
We could discuss what most people are planning to do, in this thread...
On Wednesday I will leave around 16h from the station (this is the only direct connection Freiburg -> Amsterdam)
Then I assume I'll be on the same train as Johannes.
Our secretary just informed me that she has booked hotel rooms for you. You should get an email with details anytime soon.
I think I didn't get anything
@Johan Commelin
@Patrick Massot I asked the secretary to resend the email.
To which email address?
Hi everyone! On Wednesday I will depart at 15:55 from the airport (this is the only flight back to Nice), I guess I will need to leave Freiburg arount 13:00?
@Johan Commelin Would you know a reliable way to go from BSL EuroAirport to Freibourg kind of late on Sunday evening (the plane lands at 22:10 if it is not late)?
@Cyril Cohen I think it should be possible to go from the airport to Basel's train station. And from there I expect regular trains to Freiburg till at least midnight. But I don't have any experience with this...
@Johan Commelin Ok, thanks, I'm looking into it.
:thinking: Johan told me the airport was unusable, so I took train tickets
@Patrick Massot From Nice I do not have much choice: the shortest train ride is still almost 9h long... so I'd rather fly to a unusable airport :joy:
what are the starting/ending times?
Well, there is no strict schedule. But in Orsay we used to start at around 09.00 AM. (That is Central European Time, for those of us used to Hong Kong time zones). I think you should go for dinner earlier than in Paris. The German restaurants aren't used to people coming for dinner after 20.00. On Wednesday you should just leave whenever your travel schedule requires you to go.
The first week of November is rapidly approaching. In the initial post in this thread, I outlined what I thought would be nice topics for this meeting.
I would like to use this workshop to work on mathematical topics revolving around geometry, algebra and number theory (e.g., manifolds, schemes, homological algebra, number fields, and any category theory that shows up along the way). Besides that we can also discuss and improve tactics/automation that will streamline our work.
@Tobias Grosser has indicated that he would like to work on Presburger arithmetic. Some people in the department have shown some interest, and might want to drop by. So it we might have to showcase the proof of the infinitude of primes a couple of times (-; If there are other things that people would like to coordinate or prepare in advance, I think now would be a good time to discuss it.
I can also announce the room where we will be meeting: SR 232 (II. OG/Stochastik)
. My office is in room 425.
What time are people planning to get in on Sunday? I'll be in Strasbourg that weekend and it looks like there are plenty of connections. Should we plan on dinner Sunday night?
I can also announce the room where we will be meeting:
SR 232 (II. OG/Stochastik)
. My office is in room 425.
Maybe I should also mention which building :lol:
It's the mathematics institute: Ernst–Zermelo Straße 1. map
This is a 5-minute walk from the main station.
I will be around 16:00 in Freiburg.
Would be great to meet for dinner.
Yes, I would very much like to discuss Presburger arithmetic.
Just to get an idea, who would be interested in discussing decision procedures for Presburger arithmetic?
In case there is some interest, I could try to prepare a small documents of things I would like to discuss and potentially useful paper references.
I am certainly interested in understanding the roadmap. I'm probably not really qualified for in-depth contributions.
Just wanted to let the other participants know that @Michael Jendrusch from Heidelberg is also joining!
I just checked out the room (232) that we will be in. There are two blackboards, a whiteboard and a projector (beamer). There is a VGA cable, but I didn't see an HDMI cable. There are plenty wall sockets. (If you want to showcase something, and you need HDMI, please take your own cable with you. Otherwise, I can try to find one somewhere.)
Should we meet on Sunday as well?
Yes, we can meet! I guess I will be in Freiburg in the early afternoon. Rob should be at the hotel at 7pm.
I'll arrive at 9pm, so I guess we'll meet tomorrow morning. Are we all in the same hotel? I'm at Apart Hotel Mathildenstraße 14. Do we have a starting time tomorrow morning?
I live in a little village south of Freiburg, so I won't meet you today. I'll be at the institute tomorrow morning at 8.30. I'm fine with starting at 9.00, like in Orsay.
I will be there from 5ish. Happy to go for dinner
I might arrive on monday
@Kenny Lau, is this last-minute booking?
mostly
@Tobias Grosser we can meet for dinner at around 7pm? Then @Rob Lewis is also in Freiburg.
@Patrick Massot I'm also at the Apart Hotel.
I am also at Apart Hotel. @Johannes Hölzl, should we meet in the lobby at 19:00?
Johan, I don't mind starting at 9 but your memories are wrong, in Orsay we started at 10 on the first day.
Johannes, I guess I'll see you during breakfast around 8:30 then.
Johan, I don't mind starting at 9 but your memories are wrong, in Orsay we started at 10 on the first day.
Surely all we can deduce is that _someone's_ memories are wrong...
I am quite sure that my memory is wrong. If I recall correctly, that happens quite often to me.
Hi, I'm also joining the workshop and though I suppose I'm quite late with introductions, I'll introduce myself either way.
I'm Michael, a student from Heidelberg. I am mostly doing machine learning on medical and biological imaging data (I come from a CS / biology background). I've started learning Lean a while ago (and have been lurking on Zulip for some time) for a project where we're formalizing biological protocols on top of microfluidic devices in terms of (symmetric monoidal) categories, so I'm trying to wrap my head around code generation and proof automation for defining types representing symmetric monoidal categories in terms of some generating objects and morphisms.
Anyway, I've arrived at the Hotel in Freiburg and I'm looking forward to the workshop.
Can you just explain (to a pure mathematician) what biology has to do with symmetric monoidal categories? I last went to a biology class about 30 years ago by the way.
I love hotels having eduroam wifi!
and the German touch: the room has the standard water boiler and a beer bottle opener
Hm, there is no eduroam in my room :-( I need to write down passwords, like a caveman
So it looks like everybody staying in the hotel will meet at 8:30 for breakfast and then we visit Johann
Can you just explain (to a pure mathematician) what biology has to do with symmetric monoidal categories? I last went to a biology class about 30 years ago by the way.
It's not really biology as much as it is microfluidics, where you can have some sample inlets or outlets (objects), together with ways to connect inlets with outlets, such as plain channels, mixers, etc., which do different things to the sample flowing through them (morphisms). Then you can "connect" the outlets of one microfluidic device to the inlets of of another (composition), or put two microfluidic devices next to each other (tensor product). The braiding is exchanging the order of two in- or outlets, which should satisfy the laws for a symmetric monoidal category. As you can flip the directionality of many microfluidic elements in a way that makes sense, you also get a dagger structure for many interesting subsets of what is possible with microfluidics.
Then you have a symmetric monoidal (dagger-) category which gives the syntax of the subset of microfluidics you're interested in and you can give semantics as a functor from that monoidal category to a more meaningful category, say a category of dynamical systems.
Also, there is this whole thing with interpreting biological processes as reaction networks, where you have some proteins and metabolites (objects), with reactions (morphisms) between them, where the outputs of some reactions may be the inputs of another (composition) and multiple reactions may happen in parallel (tensor product), and then you have some functors to give semantics to those reaction networks.
To add more to @Michael Jendrusch 's comment, the work of John Baez and collaborators recently has been heavily focused on treating 'network theory' (in a very broad sense) using categories: http://math.ucr.edu/home/baez/networks/
I finally arrived to the hotel
On the subject of the surprising appearances of category theory in "applied" fields; Fong and Spivak's new text "Seven sketches in compositionality" is quite amazing.
As an example, one of its chapters is called "Electric circuits: Hypergraph categories and operads"
Hallo, I'm at the breakfast
ich bin auch fertig
I looked up use of "fertig" and it means "ready" and also "exhausted"... seems confusing
Lol, in this context it definitely means "I'm ready (to go)"
Johannes is now lecturing about how to review PR's (and potentially accept a few of them).
vids plz
do you have skype?
I'm skyping Kevin Buzzard now
but I can also accommodate you
ok, I am @di..gama, but if you have vid setup you should record instead so others can see it
We are currently looking at https://t.co/K6iX1lo6z5
:)
lol, isn't this his presentation for lean together? spoilers...
Eh, that one should probably have a slightly different focus (externals instead of internals) if I don't get lazy...
Just read the slides, @Sebastian Ullrich, looks fantastic! :-)
I'M EXCITED
I think time will measure my excitement but I'm still excited!
I hereby officially declare the first day of this workshop to be a Great Success™.
one merge every 3 minutes!
Just look at this: https://github.com/leanprover/mathlib/pulse/daily
:bell: Don't forget to compile the latest mathlib tonight (-; Otherwise you'll have to be waiting the first hour tomorrow morning... your computers are all in for some serious learning of new stuff. :lol: :graduate:
plus one of the 15 or so PRs that was merged had a bug, and now mathlib is broken
*was broken
so do we have some goals to achieve?
[ ] Hilbert basis
[ ] Sheaves
[ ] Manifolds
[ ] Limits/colimts
[ ] Adjoint functors
Galois theory, algebraic closure, perfectoid spaces, existence of non-cyclic groups
even my trick of making a copy and ensuring little changes still can't make the compilation faster...
I'm going to sleep now, but I've got something for you guys to puzzle over tomorrow: leanprover-community/pfilter is beginning work on generalizing filters to preorders. @Johannes Hölzl if you have any ideas for how all your lifting and monad stuff works when separating the two levels of sets out, I'd like to hear it. I have not figured out what the new version of join
has to do with the old one (which has a different type - filter (filter A)
becomes pfilter (set (pfilter A))
which is not obviously related to pfilter (pfilter A)
, which is something new).
Good morning and sleep tight!
@Johan Commelin veele dank voor de workshop, and thanks to everyone for teaching me German and French :p
(why is nobody online?) @Johannes Hölzl asked me if a(b+c) = ab+ac for ideals, and I said no at the time, but I have since realized that it is actually true, and I have pushed my proof. In other news, German trains are nice to work in!
Yes, this is true. The thing that's basically never true for ideals is additive cancellation: I+J=I+K is a long way from J=K, e.g. (n)+(m)=(gcd(m,n)) in int, so (2)+(3)=(2)+(5)=(1).
you guys need to be more productive!
Multiplicative cancellation is sometimes true, but only in the 1-dimensional case, e.g. integers of a number field or Dedekind domains more generally (e.g. PID's) or when the underlying ideal you're trying to cancel is locally free of rank 1 (e.g. principal when R is an integral domain)
feel free to comment on the PR
us guys have got to prepare lectures, go to committee meetings, organise meetings with MSc and PhD students, run seminars, cook for our family etc etc. You have no idea how much work is involved in being a grown-up
I mean, the people in the workshop
I'm the only one leaving at 10, they're all staying there for a while longer!
They might have to do the same :-) Every night in Paris I had to leave with Patrick and spend the evening doing admin (organising interviews for a PhD studentship and dealing with emails etc)
well they're already there, as they have already commented on my PR
see you guys in the next train (if there is wifi!)
We've been watching @Cyril Cohen give a demo of SSreflect. It looks really powerful. And the good news: in principal we can have this in Lean (4?) as well.
Oh, I would have liked to have seen that.
you should have come! :p
Dear all, thank you so much for this interesting visit. I am very much looking forward to the next lean meeting!
Thank you all very much for your warm welcone. And also for teaching me how to use lean. I am really interested in continuing my experiments and also coming to the next lean meeting.
@Cyril Cohen w.r.t to param
: The constructor types provided to add_inductive
refer to the type using already the constant to be defined. So the name map would be just: bool
-> const `bool uparams
@Johannes Hölzl yes I figured that out and completed the translation.
Now, is there a way to assign the result of a run_cmd
to a variable (in order to propagate the translation table around?)
(and I pushed the result if you want to have a look)
You can use attributes
@Johannes Hölzl can you point me towards a tutorial, or a (documented) example?
so attributes are named databases which associates a list of theorems (and optional data) to each attribute.
first, they are defined in lean/library/init/meta/attribute.lean
you set up a new attribute using:
@[user_attribute] meta def mono_rules : user_attribute := { name := `mono_rules, descr := "lemmas usable to prove monotonicity" } attribute [mono_rules] add_le_add mul_le_mul_of_nonneg_right
I guess you want to associated the paramtricity relation to the type using the attribute?!
I think it's even better to use cached attributes here, if I understand the situation right. I'll try to set it up in a few min.
I want to replace a "current" consts
map after each call to param2.inductive
Do you want param2.inductive
to take consts
as an argument, or generate the current map automatically?
Wait, this shouldn't matter. You won't be calling param2.inductive
manually, right?
Just pushed something, is this roughly what you need? You'll probably want to change it a bit.
@Rob Lewis I'll take a look and tell you.
I just need to go through security first.
@Rob Lewis I think I understand. Should I replace the argument consts
of all my functions by parametricity_attr.get_cache
?
Yep, but it might take a little refactoring, since parametricity_attr
depends on some of those functions.
@Cyril Cohen Welcome to the dark side. We definitely want to steal all your mathcomp work on analysis, and it will be great to have your help.
(We can also steal ideas from his work on homology: https://perso.crans.org/cohen/papers/fpmods.pdf, https://perso.crans.org/cohen/papers/slides_fpmodules_marelle.pdf.)
@Johan Commelin Let me add to the expressions of thanks for hosting this! It was both fun and productive, a good combo.
Can I deduce from this that you caught your train and that it has wifi?
Yes !
And thank you very much for hosting this!
@Jeremy Avigad we already started porting https://github.com/math-comp/analysis/blob/master/landau.v
That's GitHub's summary of our hackathon!
LUG Freiburg 2018 — Report
We had a Lean User Group in the mathematical institute of Universität Freiburg on November 5–7, 2018.
Participants: Cyril Cohen, Johan Commelin, Johannes Hölzl, Tobias Grosser, Micheal Jendrusch, Kenny Lau, Rob Lewis, Patrick Massot
Johannes gave an update of the development status of Lean 4. Cyril gave a demo of SSreflect.
There were 23 pull requests merged into mathlib (the main mathematical library of Lean) and 6 new pull requests were created. This resulted in 7594 lines added to mathlib and 3163 deletions, changing 100 files.
The topics of these changes include the definition of the perfect closure of a field and the Stone–Cech compactification of a topological space. The Hilbert basis theorem was proved, after a major refactoring of the theory of modules. Others have worked on monoidal categories, sites and sheaves, little-o calculus, transport of structure and improvement of automation tactics. These projects are not finished yet, but should be merged into mathlib in the future.
The participants agreed that the face-to-face collaboration will ease future digital collaboration and that the workshop gave a valuable boost to the development of formalized mathematics in Lean.
(If you have any feedback for this little report, please let me know.)
(My report was PowerPoint karaoke using Sebastian's slides he presented at the end of his MSR internship )
are the slides about Lean 4 online somewhere?
yep: http://leanprover.github.io/presentations/20181012_MSR/
there is also:http://leanprover.github.io/talks/LeanAtGalois.pdf
thank you! :)
Thanks for the report Johan! Of course it must be emphasized that all those merged PR wouldn't haven't mergeable without first having be written before the meeting, and often by people not attending the meeting. And also I think Mario participated in the merge effort from Pittsburg. Nonetheless I agree this was a very successful meeting. Maybe it's worth pointing out to some of your readers that Cyril only installed Lean the day before the workshop, and is now writing both regular Lean and meta-programming. I think it's a huge success that this meeting was able to welcome such an expert Coq user to our Lean community.
I'm not sure who the audience of the report is, but I'd put the sentence about statistics at the end.
I think it's worth mentioning the (existence of) "remote" participants, too. It's fun to wake up in the morning and see progress on favourite things having happened overnight on the other side of the world. :-)
And I want to beg that future Lean meetings stream more. :-)
@Chris Hughes you should have come! :P
@Johannes Hölzl du hast noch ein ander PR :D
(@Mario Carneiro this means: you have yet another PR)
(@Mario Carneiro this means: you have yet another PR)
why the english?
he has to translate because he doesn't realize that everyone here uses the same language: lean
Well, he should have translated to Portuguese right?
don't encourage him
Ok, I've updated the report after your suggestions. I will send it to my supervisors.
merged!
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


3 references to PSEventArgsReceived
System.Management.Automation (3)
engine\remoting\client\RemoteRunspacePoolInternal.cs (1)
183
DataStructureHandler.
PSEventArgsReceived
+= HandlePSEventArgsReceived;
engine\remoting\client\RemotingProtocol2.cs (2)
193
Dbg.Assert(
PSEventArgsReceived
!= null,
196
PSEventArgsReceived
.SafeInvoke(this, new RemoteDataEventArgs<PSEventArgs>(psEventArgs));


Test Group API
Role only take in 3 characters, and "adm" is administrator. Put "usr" for regular members.
Group name:
Owner phone number:
Group id:
Group id:
Phone number:
Group id:
Owner phone number:
Group id:
Old owner phone number:
New owner phone number:
Group id:
Owner phone number:
New name:
Group id:
Admin phone number:
New member phone number:
Role:
Group id:
Admin phone number:
Member phone number:
Role:
Group id:
Admin phone number:
Member phone number:
Group id:
Group id:
Old owner phone number:
New owner phone number:
Victim phone number:


| Class Summary |
|
AmbiguousException
|
simple distinguishable exception, used when
we run across ambiguous overloading
|
|
ClassMap
|
A cache of introspection information for a specific class instance.
Keys {@link java.lang.Method} objects by a concatenation of the
method name and the names of classes that make up the parameters.
|
|
IntrospectionCacheData
|
Holds information for node-local context data introspection
information.
*
|
|
Introspector
|
This basic function of this class is to return a Method
object for a particular class given the name of a method
and the parameters to the method in the form of an Object[]
The first time the Introspector sees a
class it creates a class method map for the
class in question. Basically the class method map
is a Hastable where Method objects are keyed by a
concatenation of the method name and the names of
classes that make up the parameters.
For example, a method with the following signature:
public void method(String a, StringBuffer b)
would be mapped by the key:
"method" + "java.lang.String" + "java.lang.StringBuffer"
This mapping is performed for all the methods in a class
and stored for
|
|
IntrospectorBase
|
This basic function of this class is to return a Method
object for a particular class given the name of a method
and the parameters to the method in the form of an Object[]
The first time the Introspector sees a
class it creates a class method map for the
class in question. Basically the class method map
is a Hastable where Method objects are keyed by a
concatenation of the method name and the names of
classes that make up the parameters.
For example, a method with the following signature:
public void method(String a, StringBuffer b)
would be mapped by the key:
"method" + "java.lang.String" + "java.lang.StringBuffer"
This mapping is performed for all the methods in a class
and stored for
|
|
MethodMap
|
|


BY Nana-wax
Given the success of the loincloth number of entrepreneurs emerged. Among this wave of entrepreneurs a brand is known both in Africa and on other continents. The evolution of Nanawax is a brain work of Maureen Ayite,who sells her articles at private sales. Nanawax offers a variety of products created from the wax., Nanawax offre une variete de produits crees a partir du wax.
The wax is in essence a piece of material that can be used to make anything we want. Here are some examples of the masterpiece represented by the wax.


References
Althoff, Tim, Cristian Danescu-Niculescu-Mizil, and Dan Jurafsky. 2014. “How to Ask for a Favor: A Case Study on the Success of Altruistic Requests.” https://arxiv.org/pdf/1405.3282.pdf.
Broido, Anna D., and Aaron Clauset. 2019. “Scale-Free Networks Are Rare.” Nature Communications. https://www.nature.com/articles/s41467-019-08746-5.
Feld, Scott L., and William C. Carter. 1998. “When Desegregation Reduces Interracial Contact: A Class Size Paradox for Weak Ties.” American Journal of Sociology.
Fisher, David N., Matthew J. Silk, and Daniel W. Franks. 2017. “The Perceived Assortativity of Social Networks: Methodological Problems and Solutions.” CoRR. http://arxiv.org/abs/1701.08671.
Génois, Mathieu, and Alain Barrat. 2018. “Can Co-Location Be Used as a Proxy for Face-to-Face Contacts?” EPJ Data Science.
Hafnaoui, Imane, Gabriela Nicolescu, and Giovanni Beltrame. 2019. “Timing Information Propagation in Interactive Networks.” Scientific Reports. https://www.nature.com/articles/s41598-019-40801-5.
Holt-Lunstad, J., T. B. Smith, M. Baker, T. Harris, and D. Stephenson. 2015. “Loneliness and Social Isolation as Risk Factors for Mortality: A Meta-Analytic Review.” Perspect Psychol Sci J Assoc Psychol Sci.
Holt-Lunstad, Julianne. 2018. “Fostering Social Connection in the Workplace.” American Journam of Health Promotion.
Lu, Zhenqi, Johan Wahlström, and Arye Nehorai. 2018. “Community Detection in Complex Networks via Clique Conductance.” Scientific Reports. https://www.nature.com/articles/s41598-018-23932-z.
McNulty, Keith. 2021. Handbook of Regression Modeling in People Analytics. https://peopleanalytics-regression-book.org/.
Newman, M. E. J. 2002. “Assortative Mixing in Networks.” Physical Review Letters.
Olguin, D., B. N. Waber, T. Kim, A. Mohan, K. Ara, and A. Pentland. 2009. “Sensible Organizations: Technology and Methodology for Automatically Measuring Organizational Behavior.” IEEE Trans Syst Man Cybern.
Paoletti, Teo. 2006. “Leonard Euler’s Solution to the Konigsberg Bridge Problem.” Convergence. https://www.maa.org/press/periodicals/convergence/leonard-eulers-solution-to-the-konigsberg-bridge-problem.
Rath, Tom. 2006. Vital Friends: The People You Can’t Afford to Live Without.
Solly, Meilan. 2020. “Before Chain Letters Swept the Internet, They Raised Funds for Orphans and Sent Messages from God.” Smithsonian Magazine. https://www.smithsonianmag.com/history/chain-letters-swept-internet-they-raised-funds-orphans-and-conveyed-messages-god/.
Stoer, M., and F. Wagner. 1997. “A Simple Min-Cut Algorithm.” Journal of the ACM.
Traag, V. A., L. Waltman, and N. J. van Eck. 2019. “From Louvain to Leiden: Guaranteeing Well-Connected Communities.” Scientific Reports. https://www.nature.com/articles/s41598-019-41695-z.
Travers, Jeffrey, and Stanley Milgram. 1969. “An Experimental Study of the Small World Problem.” Sociometry. http://snap.stanford.edu/class/cs224w-readings/travers69smallworld.pdf.
Ugander, Johan, Brian Karrer, Lars Backstrom, and Cameron Marlow. 2011. “The Anatomy of the Facebook Social Graph.” https://arxiv.org/pdf/1111.4503.pdf.
Wickham, Hadley. 2016. ggplot2: Elegant Graphics for Data Analysis. https://ggplot2-book.org/.
Wickham, Hadley, and Garrett Grolemund. 2016. R for Data Science. https://r4ds.had.co.nz/.
Xie, Yihui, Christophe Dervieux, and Emily Riederer. 2020. R Markdown Cookbook. https://bookdown.org/yihui/rmarkdown-cookbook/.
Yang, Zhao, René Algesheimer, and Claudio J. Tessone. 2016. “A Comparative Analysis of Community Detection Algorithms on Artificial Networks.” Scientific Reports. https://www.nature.com/articles/srep30750.
Zachary, W. W. 1977. “An Information Flow Model for Conflict and Fission in Small Groups.” Journal of Anthropological Research.


This is part of the old website. New website begins at fontforge.github.io
Are you a web developer? Help us migrate this page on Github
In the bitmap view it will open an outline view on the current glyph.
In the metrics view it will open an outline view on whatever glyph is active.
This menu item is always grey in an outline view.
Note: It is possible to have more than one window displaying the same glyph. Any editing that occurs in one should be reflected in all.
In the outline view it will open a bitmap view on the current glyph. It will pick a pointsize.
In the metrics view it will open an outline view on whatever glyph is active, as with the font view, if it is displaying a bitmap it will use its pixelsize, otherwise it will pick a pixelsize.
This menu item is always grey in an bitmap view.
Note: It is possible to have more than one window displaying the same glyph. Any editing that occurs in one should be reflected in all.
In the outline view it will open a metrics view displaying the current glyph. The display will be an outline.
In the bitmap view it will open a metrics view displaying the current glyph. The display will be a bitmap in the current size.
This menu item is always grey in the metrics view.
It is possible to have more than one metrics view open at a time.
After that the window menu is just a list of all the open windows. If the window has been changed (and not saved since) then it has a white background. The names of font views are in red. Views connected to a given font will all be displayed together (with the font view on top). Clicking on an entry raises that window.


public interface Aggregator
| Modifier and Type | Method and Description |
|---|---|
Object |
aggregate(Evaluator evaluator,
TupleList members,
Calc calc)
Applies this aggregator to an expression over a set of members and
returns the result.
|
Object |
aggregate(List<Object> rawData,
Dialect.Datatype datatype)
Applies this aggregator over a raw list of objects for a rollup
operation.
|
Aggregator |
getRollup()
Returns the aggregator used to combine sub-totals into a grand-total.
|
boolean |
supportsFastAggregates(Dialect.Datatype datatype)
Tells Mondrian if this aggregator can perform fast aggregation
using only the raw data of a given object type.
|
Aggregator getRollup()
Object aggregate(Evaluator evaluator, TupleList members, Calc calc)
evaluator
- Evaluation contextmembers
- List of members, not nullcalc
- Expression to evaluateboolean supportsFastAggregates(Dialect.Datatype datatype)
aggregate(mondrian.olap.Evaluator, mondrian.calc.TupleList, mondrian.calc.Calc)
.
This is only invoked for rollup operations.
datatype
- The datatype of the object we would like to rollup.Object aggregate(List<Object> rawData, Dialect.Datatype datatype)
SegmentBody
object.
Only gets called if
supportsFastAggregates(mondrian.spi.Dialect.Datatype)
is true.
This is only invoked for rollup operations.
rawData
- An array of values in its raw form, to be aggregated.


SimpleGraph
A very basic graph gem for Ruby.
Currently only unweighted, undirected graphs are supported. This means that multiple edges between nodes are ignored, although self loops are allowed.
Warning
Note that this is a very early version, and everything about this library is subject to change at any given time without notice. Expect breaking changes.
Installation
Add this line to your application's Gemfile:
gem 'simple_graph'
And then execute:
$ bundle
Or install it yourself as:
$ gem install simple_graph
Documentation
Docs are built using YARD and are available at https://vesther.github.io/simple_graph/
Usage
Quickstart
require "simple_graph"
# Creating a new, empty graph
graph = SimpleGraph::Graph.new
# Adding nodes to the graph
# Creates a empty node containing only a autogenerated identifier
# Returns a graph-unique identifier for the newly created node
foo = graph.add_node()
# IDs can also be set manually
graph.add_node(id: "Kevin")
# Graphs can also hold arbitrary information in the 'data' hash
stuff = {
age: 21,
depression: true
}
= graph.add_node(id: "Igor", data: stuff)
# Edges can be created by passing the two node IDs to the connect_nodes method
graph.connect_nodes(foo, "Kevin")
# Paths between two nodes can be found by breadth-first search
paths = graph.find_paths(foo, )
# Retrieving info about the graph
graph.nodes # Lists all of the nodes in the graph
graph.node_count # Returns the amount of nodes in the graph
graph.node_ids # Array of node identifiers in the graph
graph.are_connected?(foo, ) # Checks whether two nodes are connected by an Edge
graph.include?("Kevin") # Checks whether the graph includes a node with the given ID
# Graphs can be written to files in the DOT format to be used with Graphviz
# Note that the node ID will be used for labels
File.write("test.dot", graph.to_dot_string)
# Export a graph to a JSON file
File.write("output.json", graph.to_json)
# Import a graph from a JSON file
graph.load_from_json(File.read("input.json"))
Contributing
Bug reports and pull requests are welcome on GitHub at https://github.com/vesther/simple_graph.
License
The gem is available as open source under the terms of the MIT License.


Guard Luis:
I've been looking for someone like you.
I trust you've seen the havoc wrought throughout Gludio Territory. It was enough to have Ol Mahum Stragglers and Turek Orcs bothering us. Now the lizardmen from the south!
The highway of the southern shoreline that leads to Giran has seen frequent attacks by Langk Lizardmen. People are scared. Even the temple priests traveling to Gludin were attacked! We Gludio guards are already stretched thin.
Will you help us?
"I'll help!"


Meet the Team page-psych
Welcome
Director
Counselors
Associates
Speech
Occupational
Meet the Team
Not sure where to start?
We can help!
Meet Our Director
Jane Doe, PhD, Licensed Psychologist
Counselors
Jane Doe, LCSW, PPS
John Doe, MA, BCBA
Jane Doe, LCSW
Jane Doe, LCSW, PPSC
John Doe, PPSC
Associates
John Doe, APCC
Jane Doe, AMFT, PPS
Speech Therapists
Jane Doe, SLP
Jane Doe, SLP
Occupational Therapists
John Doe, OT
John Doe, OT
Designed & Coded by Cole Crum


Preparation time
less than 30 mins
Cooking time
10 to 30 mins
Serves
Makes 10 fritters
Dietary
These savoury fritters are the perfect accompaniment to fried chicken or pulled pork.
To make the fritters, put the sweetcorn and spring onions into a bowl. Beat the eggs with the milk. Pour this mixture over the sweetcorn and mix well. Season with salt and pepper. Sieve the flour with the cayenne pepper and then stir into the sweetcorn.
Add the oil to a large frying pan – you need to shallow fry these, so make sure the base of the pan is well covered. (CAUTION: hot oil can be dangerous. Do not leave unattended.) Heat the oil then test by adding a tiny bit of the batter – it should immediately start bubbling around the edges when it hits the oil. Using a small ladle, drop batter onto the oil – you need around 2 tbsp of mixture per fritter. You should be able to fry 4-5 at any one time. Fry for a couple of minutes on one side until a light brown then turn over and cook for a further minute.
Turn out onto kitchen towel to blot off any excess oil and keep warm. Continue until you have used up all the batter.


---
#layout: post
title: Scala protected methods aren't that much protected
date: '2014-08-19T13:20:00.002+03:00'
author: Paul Lysak
tags:
- Java
- Scala
modified_time: '2014-08-19T15:14:49.595+03:00'
blogger_id: tag:blogger.com,1999:blog-5849718801312198988.post-4194829092541079085
blogger_orig_url: http://paullysak.blogspot.com/2014/08/scala-protected-methods-arent-that-much.html
years: ['2014']
---
Just discovered weird behavior of Scala's protected methods: they're actually compiled to public methods in byte-code. Therefore if you try to override them in Java code with another protected method compilation will fail with something like this: "attempting to assign weaker access privileges; was public"
. After some googling I've discovered that other people also spotted this issue. I think such weird compiler behavior was needed because of access level mismatch in Scala and Java - but I thought that Scala's protected
is more restrictive then Java's. So I'm yet to figure out reason of such behavior. By the way, package-level protected (like protected[yourpackage]
) is also compiled to public
- at least for Scala 2.10.0


MDL Chengdu Major Team Previews
by YongeleeThe first major tournament is finally happening and we're taking a closer look at all the teams participating and their odds of winning it all. The winner is pretty much guaranteed a spot at TI10 with the amount of points they're going to win.
Which region will show up? Which player will dominate? Which hero will be deemed overpowered? And most importantly, which team will win it all?
EHOME - 13.00 odds
One of the most recognized organizations coming out of China, this team has been missing from major tournaments in the past few years. The last major tournament they played in was Starladder Minor Season 2 where they failed to survive the group stage. That was a different team though and they've since changed their cores and are off to a great start this season by playing in the first major.
This team features legendary Wings players, Faith Bian and y. y was the captain of the legendary Wings squad and Faith Bian was the offlaner who some hailed as the number 1 Dota 2 player during their reign. The team's fall from the top is one of the saddest stories in Dota 2 history but these two players are back at a major tournament.
At 13.00 odds, Unikrn puts this team in tier 2 of teams at this tournament. This team isn't a safe bet because this group of players haven't proven themselves on the big stage. Faith_Bian and y have proven themselves and may have to show the world that they shouldn't have been forgotten by winning it all.
INVICTUS GAMING - 19.00 odds
This team won the Dota Summit 11 and only lost one game during the entire tournament. It was a pretty dominant run and they clearly proved they were the best team there.
This is a team that didn't even make the playoffs during the Chinese qualifiers for MDL Chengdu.
Their mid player, Emo, is becoming a breakout star. He's only 18 years old and was perhaps the most impressive part of IG's run during the Summit 11. His potential was known for a long time though, earning a shout out from Sumail in June 2018. Half was his old name.
Kaka is a TI7 grand finalist from the iconic Newbee squad. He played incredibly during the Summit 11, running from lane to lane to secure kills and the lane for his team.
Now at this tournament they'll be facing the top talents from the world and not tier 2 teams like at the Minor.
The last time a Chinese team won a Minor to make it to a Major was Vici Gaming. That team won StarLadder Season 1 which qualified them for DreamLeague season 11. They won that tournament and then became one of the top tier 1 teams in all of Dota for the rest of the season.
Can IG pull this off? They have the potential to do so. Their talent is a little bit behind the top tier teams but they can certainly pull off some upsets which will be required if they want to make a deep run. This team seems like they can finish anywhere from last to first but Unikrn put them at 19.00 odds which is around the middle of the pack.
Team Liquid - 23.00 odds
This is not the Team Liquid you're used to, this is a completely new squad. These five players were formerly known as Alliance in the last year and now they've switched organizations and are the new face of Team Liquid.
Not much has changed from this squad other than the organization change and changing coaches from Loda to Blitz. They're still the same five players.
They're not interested in replacing the old Team Liquid squad, they want to carve out their own name. So far that hasn't been off to a great start.
They were at the bottom of their groups during ESL One Hamburg 2019 and placed 4th at the 6 team tournament: DreamLeague Season 12.
At TI9 they infamously were knocked out in the first round of the lower bracket after accidentally picking Gyrocopter when they meant to ban him. But just before TI9 they won it all at Dota Summit 10 but they were the only team going to TI9 at that tournament.
At 23.00 odds this seems oddly appropriate. They've yet to prove themselves against top tier talent but have shown that they're able to compete at the same tournament. This could be the tournament they break out and show out but they're just as likely to blow out and be the first team eliminated. Expect a low to mid-level finish for this team.
TNC Predator - 6.00 odds
This is a new look from the TNC team that fans are used to. They've replaced KuKu and eyyou with Kpii and March and immediately found success. Fresh off their ESL One Hamburg 2019 tournament win, this team is ranked 3rd most likelly to win it all at 6.00 odds.
The competition at ESL One Hamburg was strong but not the strongest. They beat Gambit Esports 3-2 in the grand finals, a series that could have gone either way.
Gabbi and Armel are considered top tier cores and many analysts compliment their skill and talent level.
Kpii is consistently a strong performer in any team he’s on. He’s a TI7 grand finalist for a reason.
Tims is the longest tenured member of TNC, joining in 2016. They’ve stuck with him this entire time for a reason and often makes huge jaw dropping plays that you expect out of a position 4.
March has had a tumultuous Dota 2 career. One of the few South Korean Dota 2 professionals, he’s had a long career before leaving to serve in the South Korean army. Since he’s been back in 2018, he’s been jumping around in North American teams but since joining TNC, he’s never lost in any tournament and won MVP for ESL One Hamburg 2019.
Since TI9 where TNC finished 9-12th, this team hasn’t lost any LAN event with their new squad. They played in 4 events, 2 minor tournaments, 1 major tournament, and 1 qualifier. Is this team the real deal?
Maybe the leadership of Kpii and March is what this team needed and so far the results have been number one. This tournament will be a true test of this team’s capabilities but if they can carry on their momentum then this tournament is theirs to lose.
Alliance - 13.00 odds
The latest iteration of the Alliance is a bunch of European talent banded together under the leadership of Dota 2 veteran Fata. Forming in October 2019, this team wasted no time in winning. The first LAN tournament they played in, DreamLeague Season 12, they won it all. At their next LAN, ESL One Hamburg 2019, they placed 3rd. Despite not playing together for a long time, they’ve gathered a ton of experience as a team.
This is Fata’s first time captaining a team but after playing under the leadership of some of the top captains Dota 2 has ever seen, Fata is doing an excellent job. He’s played with Kuroky at Team Liquid, Puppey at Team Secret, and PPD at Ninjas in Pajamas.
This team is loaded with European talent who before joining Alliance, were standout players with their old teams. Now playing together under an iconic Dota 2 organization and the leadership of Fata, they’re showing the world they’re next up for greatness. At 13.00 odds this team is in the 2nd tier of teams ranked at this tournament.
Can they pull off some upsets? Perhaps it should be expected. Perhaps it shouldn’t. It’s hard to tell with this team and the level of competition at this tournament.
J.Storm - 41.00 odds
J.Storm, the North American team that does not give up. This team hasn’t seen tremendous success in the past but they never stopped trying or disbanded. Their first LAN win was at WSOE 6: Dota 2 - Serenity's Destiny, a private tournament by a 3rd party organizer.
This team was founded in September 2018 and their first LAN win was in April 2019.

Moo is a 2nd place TI6 player who was known for playing offlane but is now the carry.
Nine is a German player who saw some success on his former teams of Team Spirit and PENTA Sports. Now he’s the mid player for J.Storm.
Brax is the offlane player and he’s been playing professionally since 2012 but his tournament results aren’t elite.
MoOz is a Peruvian postion 4 player who used to be a player for Infamous.
Fear is a legendary Dota 2 player and TI5 champion. He famously carried for EG but now is playing position 5 for J.Storm as his mechanical abilities has declined but his game knowledge keeps growing and growing and that plus his age makes him best suited for position 5 at this stage.
At 41.00 odds, not much is expected from this team. Their talent level doesn’t stand out and Fear hasn’t shown any magic as a captain. This team hasn’t had deep runs in many tournaments but who knows, maybe this will be the one.
Trivia fact: this team is Jeremy Lin’s team. This organization was also known as VGJ.Storm before they parted ways with Vici Gaming.
Vici Gaming - 5.00 odds
This team has a long history of success and deep runs at tournaments. They’re one of the top elite teams that always have a chance at winning it all at any tournament they play in because they’re so talented, have a great coach, and play well together as a team.
They finished 5th-6th at TI9 and won 2 majors last DPC season at EPICENTER and DreamLeague Season 11.
Their most recent outing was at ESL One Hamburg 2019 where they finished 5th-6th. They lost two series in a row during the main event. They were arguably the favorites to win it all that tournament.
At 5.00 odds, this team is rated the 2nd most likely team to win it all. It makes sense considering the other teams participating and how much more successful Vici Gaming is compared to them.
They have the talent and experience to win it all as they’ve done in the past. Pyw will have to fill some big shoes since he’s replacing Fade who was one of the breakout players in the past DPC season.
Team. Spirit - 23.00 odds
A new team but not a new organization. Team Spirit was founded in 2015 but hasn’t managed to make themselves a recognized name in the world of Dota.
This squad was put together in September 2019 under the name “Positive Guys” and after qualifying for the MDL Chengdu Major tournament they were picked up by Team Spirit.
At 23.00 odds, Unikrn thinks this team is more likely to win it all than teams like Fighting PandaS and J.Storm. While this team does have talented players, they haven’t proven themselves at all. Since playing together in September 2019, they finished 2nd at the Reshuffle Madness tournament, losing to Navi 3-2. That was a good run but the competition wasn’t fierce like it will be at MDL Chengdu.
This team will have to pull out some impressive strategies and plays in order to upset the competition. Expect a finish in the low to mid area for this squad.
Evil Geniuses - 4.50 odds
It is hard to tell whether Evil Geniuses won or lost in the aftermath of the post-TI shuffle. On one hand they've lost Sumail, who was an integral piece of their roster for the last several years. On the other, we feel like Ramzes and Abed are better suited to enable Arteezy and his playstyle and allow him to go absolute ham in his games on the back of an economic advantage he can create out of thin air.
Perhaps considering Evil Geniuses the favorites of the tournament is a bit premature, but it is definitely the biggest name on stage at the first Major of the season and the roster does look good on paper. Their convincing run through the qualifiers bolsters this idea and with the amount of LAN experience and LAN Championship titles in mind, the 4.50 odds start to make a lot of sense.
Evil Geniuses was and still is North America's biggest hope and their incredibly multi-national squad can be off to a great start in this DPC season, especially considering the absence of the strongest contenders.
Fnatic - 9.00 odds
Fnatic is a team that is always close to the top, but rarely gets the elusive title. We also didn't get to see them play against TNC during the SEA qualifiers, so it is incredibly hard to gauge their current strength.
It is an incredibly strong team on paper: DJ, Jabz, Iceiceice and Moon are the veterans of Dota who were always among the best on their positions. That means that the 9.00 odds are more than justified.
23Savage, however, is an unknown and it is going to be his first LAN of this caliber. Will the pressure get to him? Or, as it is frequently the case with the younger core players, the stage is going to fuel his prowess? We don't know, but we know that Fnatic's success will certainly depend on that.
Team Aster - 13.00 odds
Ex-VG Fade has a lot to prove. He left his former team in a rather dramatic fashion, but now has a chance to make his strategies do the talking—with Sccc and Boboka on his team, there is certainly no lack of skill and play-making potential, so his ability as a captain will be tested in a somewhat controlled environment.
Top it with a legendary coach, Mikasa, and you potentially get the next big Chinese team in the making. Team Aster shared the first place with Vici Gaming during the qualifiers, but didn't get a chance to play against them, so there are still a lot of questions. Questions that will hopefully get answered during the tournament.
Unikrn certainly believes in this new team, putting them on par with both Gambit and Alliance, and even ahead of Beastcoast.
Unknown Team - 67.00 odds
South America is one LAN win away from finally getting the respect it deserves. The current Beastcoast roster showed everyone at TI that SA is not to be trifled with and guess who they were training against? While Team Unknown is definitely not among the favorites of the tournament, we feel like they aren't as clear of an outsider either.
This team is also quite interesting in how it is assembled. Most conventional teams focus on getting older, more experienced supports and young, flashy cores, but Unknown is kind of an opposite of that. We rarely get to see truly unique teams on the big stage and team Unknown might be able to scratch that itch.
Adroit - 41.00 odds
The third SEA slot is a very young team with some rather old players. Both Boombacs and cml have been in the scene for a very long time, finding success in the local tournaments, but rarely getting outside of the SEA. Given the level of competition in the region and how, until recently, it was considered "weak" when it came to qualifier slot allocation, it is understandable and we feel like Adroit might be a lot better than all of us assume.
Unikrn agrees with us, putting the team on par with J.Storm. Neither team is expected to win the tournament, but both of them have a real chance of getting into top8. They have some pretty tough competition during the group stage and might have trouble getting into the upper bracket, but long lower bracket runs is nothing new for the SEA.
beastcoast - 21.00 odds
These odds are possibly the only ones we fully disagree with and can't quite understand. Beastcoast was a team that got top8 in the International 2019. If we take former Liquid, Team Secret, PSG.LGD and OG out of the equation, since they are not attending the first Major, Beastcoast is one of the top 3 teams attending the tournament. Yet, they are valued below iG, Aster, and EHOME, who are all yet to prove themselves.
Moreover, in the recent ESL One Beastcoast handily beat Fighting Pandas and managed to win their series with Vici Gaming. The latter was playing with a stand-in, certainly, but the core of the team was intact and it still crumbled under the pressure of the South American superstars.
This can realistically be the first South American international LAN victory and perhaps it will finally end the under-appreciation of the region, which has essentially created the templates for farming on certain heroes that are now used ubiquitously.
Fighting PandaS - 34.00 odds
Joined by a TI winner Aui_2000 and multiple Major winner Moonmeander, Envy finally gave up on trying to foster new talent and went for reliable players, hoping to secure some DPC points early in the season. And we have to be fair: in theory, this team does look good.
It is also the return of Envy to the carry position, a very welcome one since Envy playing carry is always entertaining. Can the stability and experience of his teammates carry him to victory? The odds of it are probably around 50%.
Gambit Esports - 13.00 odds
The only team Gambit lost more than one game to in the ESL One was TNC, who took the first place in a brutal, full best of five. That means that Gambit, by all means, is a good team and objectively the best team in the CIS.
We don't know whether being the best in the CIS will amount to anything on the international stage and ever since the former Virtus.Pro disbanded the region looked like it is in a disarray. This same state of uncertainty is probably the biggest factor when it comes to Unikrn odds for the team: 13.00 is higher than Fnatic, TNC, Vici Gaming and Evil Geniuses and on par with Alliance, Aster and EHOME.
Gambit won a bo3 vs. both Vici Gaming and Alliance during ESL One and could probably take on Fnatic as well, since we feel like it is weaker than TNC, but only time will tell. We are, however, pretty hopeful.


XLS Solvers
Programs that are represented as optimized XLS IR are converted into circuits based on boolean logic, and so it is also possible to feed those as logical operations to a theorem prover.
We have implemented that conversion with the Z3 theorem prover using its "bit vector" type support. As a result, you can conceptually ask Z3 to prove any predicate that can be expressed as XLS, over all possible parameter inputs.
See the tools documentation for usage information on related command line tools.
Applications
This facility is expected to be useful to augment random testing. While profiling the values in an XLS IR function that is given random stimulus, we may observe bits that result from nodes that appear to be constant (but are not created via a "literal" or a "concat" of a literal).
Example: Say the value resulting from and.1234
in the graph appears to be
constant zero with all the stimulus provided via a fuzzer thus far -- the solver
provides a facility whereby we can ask "is there a counterexample to and.1234
always being zero?" and the solver will either say "no, it is always zero", or
it will yield a counterexample, or will not terminate within the allocated
deadline.
Assuming we can prove useful properties in a reasonable amount of time, we can use this proof capability to help find interesting example inputs that provide unique stimulus.
Correctness WRT reference: 32-bit Floating-Point Adder
The full input space for a 32-bit adder is a whopping 64 bits - far more than is possible to exhaustively test for correctness. Proving correctness via Z3, however, is relatively straightforward: at a high level, one simply compares the output from the DSLX (translated into Z3) to the same operation performed solely in Z3.
In detail, the steps are:
- Translate the DSLX implementation into Z3 via
Z3Translator::CreateAndTranslate()
. - Create a Z3 implementation of the same addition. This is nearly trivial, as Z3 helpfully has built-in support for floating-point values and theories.
- Take the result nodes from each "branch" above and create a new node subtracting the two. This is the absolute error. Note: Usually, one is interested in relative error when working with FP values, but here, our target is absolute equivalence, so absolute error sufficies (and is simpler).
- Create a Z3 node comparing that error to the maximum bound (here 0.0f).
- Feed that error node into a Z3 solver, asking it to prove that the error could be greater than that bound.
If the solver can not satisfy that criterion, then that means the error is never greater than that bound, i.e., that the implementations are equivalent (with our 0.0f bound).
IR Transform validity
It's usually not possible (or is merely extremely difficult) to write tests to prove that an optimization/transform is safe across all input IR. By comparing the optimized vs. unoptimized IR in a similar manner as the correctness proof above, we can symbolically prove safety.
The only difference between this and the correctness proof is that both the
optimized and unoptimized IR need to be fed into the same Z3Translator (the
second via Z3Translator::AddFunction()
) and the result nodes each are used in
the error comparison.
IR to netlist Logical Equivalence Checking (LEC)
After a user design has been lowered to IR, it is optimized (see the previous section), then Verilog is generated for that optimized IR. That Verilog is then compiled by an external tool, which, if successful, will output a "netlist" - a set of standard cells (think AND, OR, NOT, flops, etc.) and wires connecting them that realizes the design.
Between the IR level and that netlist, many, many transformations are applied to the design. Before processing the netlist further - and certainly before sending the final design to fabrication - it's a very good idea to ensure that the netlist describes the correct logic!
Demonstrating initial design correctness is up to the user, via unit tests or integration tests at the DSLX level. At all stages below that, though, ensuring logical equivalence between forms is XLS' responsibility. To prove equivalence between the IR and netlist forms of a design, XLS uses formal verification via solvers - currently only Z3, above.
Performing IR-to-netlist LEC is very similar to the checking above - the source IR is one half of the comparison. Here, the second half is the netlist translated into IR, which only requires a small amount of extra work. Consider the snippet below:
FOO p1_and_1 ( .A(p0_i0), .B(p0_i1), .Z(p1_and_1_comb) );
BAR p1_and_2 ( .A(p0_i2), .B(p0_i3), .Z(p1_and_2_comb) );
These lines describe, in order:
- One cell, called
FOO
, that takes two inputs, .A and .B, provided by the wiresp0_i0
andp0_i1
, respectively, and one output, .Z, which will be assigned to the wire `p1_and_1_comb. - One cell, called
BAR
, that takes two inputs, .A and .B, provided by the wiresp0_i2
andp0_i2
, respectively, and one output, .Z, which will be assigned to the wire `p1_and_2_comb.
Note that the values computed by the cells wasn't mentioned - that's because
FOO
and BAR
are defined in the "cell library", the list of standard cells
used to generate the netlist. Thus, to be able to model these gates in a solver,
we need to take that cell library as input to the LEC tool. The netlist
describes how cells are laid out, and the cell library indicates what cells
actually do. With both of these in hand, preparing the netlist half of a LEC
is a [relatively] straightforward matter of parsing a netlist and cell library
and converting those together into a description of logic. See
z3_netlist_translator.cc
for full details.
Utilities
- tools/lec_main.cc: Driver function for performing IR-to-netlist LEC.
- solvers/python/z3_lec.cc: Wrapper to perform IR-to-netlist LEC from Python.
Current Limitations
Time-to-result
Under the hood, Z3 (and many other tools in this space) is an SMT solver. At a high level, think of an SMT solver as a SAT solver that has special handling for certain classes of data (bit vectors, floating-point numbers). Many sufficiently complicated problems will reduce to raw SAT solving (especially those involving netlists, which have to implement complex logic at the gate level. Consider what that means for a multiply, for example!). Since SAT scales exponentially with the size of its inputs, execution time can quickly grow past a point of utility for complex operations, notably multiplication. Fortunately, for most designs (without such complex ops), proving equivalence of a single pipeline stage can complete in a small amount of time (O(minutes)).
Predicate coverage
Hypothetically, any XLS function that computes a predicate (bool) can be fed to Z3 for satisfiability testing. Currently a more limited set of predicates are exposed that can be easily expressed on the command line; however, it should be possible to provide:
- an XLS IR file
- a set of nodes in the entry function
- a DSLX function that computes a predicate on those nodes
Which would allow the user to compute arbitrary properties of nodes in the function with the concise DSL syntax.
Subroutines
Z3 doesn't intrinsically have support for subroutines, or as they're called in Z3, "macros", instead requiring that all function calls be inlined.
There is an extension that adds support for recursive function decls and defs, but in our experience, it doesn't behave the way we'd expect.
Consider the following example:
package p
fn mapper(value: bits[32]) -> bits[32] {
ret value
}
fn main() -> bits[1] {
literal_0: bits[32] = literal(value=0)
literal_1: bits[1] = literal(value=1)
elem_0: bits[32] = invoke(literal_0, to_apply=mapper)
eq_12: bits[1] = eq(literal_0, elem_0)
ret and_13: bits[1] = and(eq_12, literal_1)
}
Here, it's trivial for a human reader to see that the results are the same; the
output should be equal to 1. Z3, however, reports that this is not necessarily
the case, suggesting that literal_0
and elem_0
would not be equal in the
case where the input to mapper
was 1...which is clearly never the case here.
To address this, we require that all subroutines (including those used in maps and counted fors) be inlined before consumption by Z3.


Wellcome To My Book Shop
Create New Book
×
Book Name
Book Price
Book Image
Add A New Book
Modal title
×
...


#include <b3OverlappingPairCache.h>
Public Member Functions | |
| b3BroadphasePair * | findPair (int proxy0, int proxy1) |
Protected Attributes | |
| bool | m_hasDeferredRemoval |
| by default, do the removal during the pair traversal |
Definition at line 286 of file b3OverlappingPairCache.h.
| b3BroadphasePair * b3SortedOverlappingPairCache::findPair | ( | int | proxy0, | |
| int | proxy1 | |||
| ) | [virtual] |
this findPair becomes really slow. Either sort the list to speedup the query, or use a different solution. It is mainly used for Removing overlapping pairs. Removal could be delayed. we could keep a linked list in each proxy, and store pair in one of the proxies (with lowest memory address) Also we can use a 2D bitmap, which can be useful for a future GPU implementation
Implements b3OverlappingPairCache.
Definition at line 490 of file b3OverlappingPairCache.cpp.
References b3AlignedObjectArray< T >::findLinearSearch(), and b3AlignedObjectArray< T >::size().
00491 { 00492 if (!needsBroadphaseCollision(proxy0,proxy1)) 00493 return 0; 00494 00495 b3BroadphasePair tmpPair = b3MakeBroadphasePair(proxy0,proxy1); 00496 int findIndex = m_overlappingPairArray.findLinearSearch(tmpPair); 00497 00498 if (findIndex < m_overlappingPairArray.size()) 00499 { 00500 //b3Assert(it != m_overlappingPairSet.end()); 00501 b3BroadphasePair* pair = &m_overlappingPairArray[findIndex]; 00502 return pair; 00503 } 00504 return 0; 00505 }


In this project, we’ll be building a live code editor similar to Codepen or JsFiddle.
Let’s get started by creating our usual three files:
To get started with our markup, we’ll be needing three textarea tags which will correspond with the id of the language we’ll be compiling. To actually show the compiled code, we will also need an iframe which will allow us to insert an html document into an existing html page. Make sure to set ids for each tag so we can communicate with these elements in JavaScript.
<html>
<head>
<title>Code Editor</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="stylesheet" href="style.css">
</head>
<body>
<textarea id="html" placeholder="HTML"></textarea>
<textarea id="css" placeholder="CSS"></textarea>
<textarea id="js" placeholder="JavaScript"></textarea>
<iframe id="code"></iframe>
<script type="text/javascript" src="app.js"></script>
</body>
</html>
Before we head on to making our app, let’s style it up a bit. We should align the elements to the center, make the textarea elements go side by side, and put the iframe right below them.
body {
text-align: center;
}
textarea {
width: 32%;
float: top;
min-height: 250px;
overflow: scroll;
margin: auto;
display: inline-block;
background: #F4F4F9;
outline: none;
font-family: Courier, sans-serif;
font-size: 14px;
}
iframe {
bottom: 0;
position: relative;
width: 100%;
height: 35em;
}
As always, feel free to customize this to your liking!
Now, here’s where we actually make our app functional. We can do so with just one function. Here’s what we’ll need to write in it:
function compile() {
var html = document.getElementById("html");
var css = document.getElementById("css");
var js = document.getElementById("js");
var code = document.getElementById("code").contentWindow.document;
document.body.onkeyup = function(){
code.open();
code.writeln(html.value+"<style>"+css.value+"</style>"+"<script>" + js.value + "</script>");
code.close();
};
};
compile();
That's it! Pretty simple right? To take this a step further, try and make the textareas responsive with media queries. If you liked this tutorial, try building a Web Paint app!


clear
Free's any internal storage and resets to the initial state.
pageout(page)
Outputs a page from the synchronisation layer.
pageseek(page)
Finds the borders of pages and resynchronises the stream.
reset
Resets the synchronization status to initial values.
write(seq)
Copies the data from the sequence into the synchronisation
layer.
|


Balance is a mutual credit system. Everyone's balance starts at zero. In the simplest transaction, one person's balance goes down and the other's goes up by an equal amount.
Keep track of complicated transactions, such as bills that one person pays, but everyone shares in. Balance keeps a running total of how much each person owes or is owed.
When the time comes to settle up, Balance will calculate the minimum number of payments required to pay everyone and bring everyone's balance back to zero.  Balance makes sure no transactions will exceed those limits. (Coming soon)
You set what permissions are needed to create, modify and remove transactions. An informal group of friends may allow any transactions, while others may require approval of each transaction.
Balance supports the currency of your choice, including time-based currencies for keeping track of hours worked. (Coming soon)
Balance is an open-source tool to keep track of shared finances for groups. Its respository is located on Github.


You name is required.
Username is too short.
Username is too long.
Enter a valid email.
At least $1000 is required!
At least 5% is required!
Invalid phone number!


Code does not contain a lowercase letter.
Code does not contain a uppercase letter.
Code must have at least eight charecters.
No spaces allowed
We are processing your data...


BODY SKIN
LAYOUT STYLE
Returning Customer ? Click here to login
Please send us your cheque by Post to : 123 Disney Street Slim Av. Brooklyn Bridge, NY, New York PO BOX 152
Open account for free and start trading Bitcoins!
Register Now


This configurable widget was developed using Dojo Toolkit, ESRI:s JavaScript API and FMEServer.js. The purpose of the FMEPortal widget is to allow quick setup of one or many customized portals for accessing FME workspaces stored on FME-server.
The workspaces in this example are from Safe Softwares demo server. http://www.safe.com
Author: Peter Jäderkvist at Community Development Gävle.


JavaScript developer with a background in project management, user experience design, music, and theater education. Passionate about using code to create tools to help benefit the greater good.
Transitioning from the operational side of Tech, Aaron is enjoying becoming a software engineer. Aaron has 5 years of Cloud Operational Experience but has been a lifelong linux and internet user. His first linux distro was Redhat Linux 4.0. Outside of the computer world, he enjoys running and taking pictures of trains.
As a new software developer, Daniel is passionate about learning all things code, all the time. He has an extensive marketing background and has worked 8+ years in the financial industry. Daniel loves sports (Go Cougs!), camping, and other basic necessities such as music and Covfefe, er, coffee.
Junior Software Developer with a jack-of-all-trades background: military, retail, construction, private security, educaton. I see coding a trade for the 21st century and look foreword to where it can take me!


Lewin A. R. W. Edwards
Indicates the skillset thought to be most important to become an embedded engineer. Important to scan and use as evidence for the engineering culture.
Unread


Hi.. Welcome to my profile!
I am an undergraduate of University Moratuwa in Computer Science and Engineering.
Currently, I am working as a software developer and a graphic designer for Vincito Solutions.
In personal life, I am a huge fan of classical music. On the other hand, I am interested in Web based application development, Android app development and Robotics
You can find me at the following places.


#include <NoiseOutStream.h>
Public Member Functions | |
| FileOutStream () | |
| FileOutStream (const std::string &filename) | |
| bool | open (const std::string &filename) |
| bool | isOpen () |
| void | close () |
| template<class T> | |
| void | write (T t) |
| virtual void | write (const void *buffer, size_t len) |
| virtual size_t | tell () |
| virtual void | seek (size_t pos) |
| void | writeInt (int t) |
| void | writeDouble (double t) |
| noisepp::utils::FileOutStream::FileOutStream | ( | ) |
Constructor.
| noisepp::utils::FileOutStream::FileOutStream | ( | const std::string & | filename | ) |
Constructor.
| filename | The name of the output file. |
| bool noisepp::utils::FileOutStream::open | ( | const std::string & | filename | ) |
Open the specified file for writing.
Returns true on success.
| bool noisepp::utils::FileOutStream::isOpen | ( | ) |
Check if a file is open.
Returns true if the stream is currently associated with a file, and false otherwise.
| void noisepp::utils::FileOutStream::close | ( | ) |
Close the current file.
| void noisepp::utils::FileOutStream::write | ( | T | t | ) | [inline] |
Write to stream and flip endian if required.
Reimplemented from noisepp::utils::OutStream.
| void noisepp::utils::FileOutStream::write | ( | const void * | buffer, | |
| size_t | len | |||
| ) | [virtual] |
Write len bytes from buffer.
Implements noisepp::utils::OutStream.
| size_t noisepp::utils::FileOutStream::tell | ( | ) | [virtual] |
Returns the current position.
Implements noisepp::utils::OutStream.
| void noisepp::utils::FileOutStream::seek | ( | size_t | pos | ) | [virtual] |
Jumps to the specified position.
Implements noisepp::utils::OutStream.
| void noisepp::utils::OutStream::writeInt | ( | int | t | ) | [inline, inherited] |
Write an integer.
| void noisepp::utils::OutStream::writeDouble | ( | double | t | ) | [inline, inherited] |
Write a double.


| pal2rgb - convert a palette color TIFF image to a full color image |
| pal2rgb [ options ] input.tif output.tif |
| Pal2rgb converts a palette color TIFF image to a full color image by applying the colormap of the palette image to each sample to generate a full color RGB image. |
| Options that affect the interpretation of input data are: |
| -C |
| This option overrides the default behaviour of pal2rgb in determining whether or not colormap entries contain 16-bit or 8-bit values. By default the colormap is inspected and if no colormap entry greater than 255 is found, the colormap is assumed to have only 8-bit values; otherwise 16-bit values (as required by the TIFF specification) are assumed. The -C option can be used to explicitly specify the number of bits for colormap entries: -C 8 for 8-bit values, -C 16 for 16-bit values. |
| Options that affect the output file format are: |
| -p |
| Explicitly select the planar configuration used in organizing data samples in the output image: -p contig for samples packed contiguously, and -p separate for samples stored separately. By default samples are packed. |
| -c |
| Use the specific compression algorithm to encoded image data in the output file: -c packbits for Macintosh Packbits, -c lzw for Lempel-Ziv & Welch, -c zip for Deflate, -c none for no compression. If no compression-related option is specified, the input file's compression algorithm is used. |
| -r |
| Explicitly specify the number of rows in each strip of the output file. If the -r option is not specified, a number is selected such that each output strip has approximately 8 kilobytes of data in it. |
| Only 8-bit images are handled. |
| tiffinfo(1), tiffcp(1), tiffmedian(1), libtiff(3) |


# Copyright(c) 2016, Oracle and/or its affiliates. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import kollacli.i18n as u
from kollacli.api.exceptions import InvalidArgument
from kollacli.api.job import Job
from kollacli.common.ansible import actions
from kollacli.common.inventory import Inventory
from kollacli.common.utils import check_arg
from kollacli.common.utils import safe_decode
[docs]class AsyncApi(object):
[docs] def async_deploy(self, hostnames=[],
serial_flag=False, verbose_level=1, servicenames=[]):
# type: (List[str], bool, int, List[str]) -> Job
"""Deploy.
Deploy containers to hosts.
:param hostnames: hosts to deploy to. If empty, then deploy to all.
:type hostnames: list of strings
:param serial_flag: if true, deploy will be done one host at a time
:type serial_flag: boolean
:param verbose_level: the higher the number, the more verbose
:type verbose_level: integer
:param servicenames: services to deploy. If empty, then deploy all.
:type servicenames: list of strings
:return: Job object
:rtype: Job
"""
check_arg(hostnames, u._('Host names'), list,
empty_ok=True, none_ok=True)
check_arg(serial_flag, u._('Serial flag'), bool)
check_arg(verbose_level, u._('Verbose level'), int)
check_arg(servicenames, u._('Service names'), list,
empty_ok=True, none_ok=True)
hostnames = safe_decode(hostnames)
servicenames = safe_decode(servicenames)
ansible_job = actions.deploy(hostnames,
serial_flag, verbose_level, servicenames)
return Job(ansible_job)
[docs] def async_upgrade(self, verbose_level=1, servicenames=[]):
# type: (int, List[str]) -> Job
"""Upgrade.
:param verbose_level: the higher the number, the more verbose
:type verbose_level: integer
:param servicenames: services to upgrade. If empty, then upgrade all.
:type servicenames: list of strings
:return: Job object
:rtype: Job
Upgrade containers to new version specified by the property
"openstack_release."
"""
check_arg(verbose_level, u._('Verbose level'), int)
check_arg(servicenames, u._('Service names'), list,
empty_ok=True, none_ok=True)
servicenames = safe_decode(servicenames)
ansible_job = actions.upgrade(verbose_level, servicenames)
return Job(ansible_job)
[docs] def async_host_destroy(self, hostnames, destroy_type, verbose_level=1,
include_data=False, remove_images=False):
# type: (List[str], str, int, bool, bool) -> Job
"""Destroy Hosts.
Stops and removes all kolla related docker containers on the
specified hosts.
:param hostnames: host names
:type hostnames: list
:param destroy_type: either 'kill' or 'stop'
:type destroy_type: string
:param verbose_level: the higher the number, the more verbose
:type verbose_level: integer
:param include_data: if true, destroy data containers too.
:type include_data: boolean
:param remove_images: if true, destroy will remove the docker images
:type remove_images: boolean
:return: Job object
:rtype: Job
"""
check_arg(hostnames, u._('Host names'), list)
check_arg(destroy_type, u._('Destroy type'), str)
check_arg(verbose_level, u._('Verbose level'), int)
check_arg(include_data, u._('Include data'), bool)
check_arg(remove_images, u._('Remove images'), bool)
if destroy_type not in ['stop', 'kill']:
raise InvalidArgument(
u._('Invalid destroy type ({type}). Must be either '
'"stop" or "kill".').format(type=destroy_type))
hostnames = safe_decode(hostnames)
inventory = Inventory.load()
inventory.validate_hostnames(hostnames)
ansible_job = actions.destroy_hosts(hostnames, destroy_type,
verbose_level, include_data,
remove_images)
return Job(ansible_job)
[docs] def async_host_precheck(self, hostnames, verbose_level=1):
# type: (List[str], int) -> Job
"""Check pre-deployment configuration of hosts.
Check if host is ready for a new deployment. This will fail if
any of the hosts are not configured correctly or if they have
already been deployed to.
:param hostnames: host names
:type hostnames: list
:param verbose_level: the higher the number, the more verbose
:type verbose_level: integer
:return: Job object
:rtype: Job
"""
check_arg(hostnames, u._('Host names'), list)
check_arg(verbose_level, u._('Verbose level'), int)
hostnames = safe_decode(hostnames)
inventory = Inventory.load()
inventory.validate_hostnames(hostnames)
ansible_job = actions.precheck(hostnames, verbose_level)
return Job(ansible_job)
[docs] def async_host_stop(self, hostnames, verbose_level=1):
# type: (List[str], int) -> Job
"""Stop Hosts.
Stops all kolla related docker containers on the specified hosts.
:param hostnames: host names
:type hostnames: list
:param verbose_level: the higher the number, the more verbose
:type verbose_level: integer
:return: Job object
:rtype: Job
"""
check_arg(hostnames, u._('Host names'), list)
check_arg(verbose_level, u._('Verbose level'), int)
hostnames = safe_decode(hostnames)
inventory = Inventory.load()
inventory.validate_hostnames(hostnames)
ansible_job = actions.stop_hosts(hostnames, verbose_level)
return Job(ansible_job)


Lorem ipsum dolor sit amet, consectetur adipisicing elit.
Lorem ipsum dolor sit amet, consectetur adipisicing elit.
Lorem ipsum dolor sit amet, consectetur adipisicing elit.
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been.
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been.
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been.
Lorem ipsum dolor sit amet.
Lorem ipsum dolor sit amet, consectetur adipisicing elit.
© Copyright 2018 Osahan Property. All Rights Reserved
Made with by Ask Bootstrap


|
Steam Audio API
2.0-beta.18
|
Describes various properties of the audio processing pipeline. More...
Data Fields | |
| IPLint32 | samplingRate |
| The sampling rate (in Hz) of any audio to be processed by Phonon. More... | |
| IPLint32 | frameSize |
| The number of samples in a single frame of audio. More... | |
| IPLConvolutionType | convolutionType |
| The convolution algorithm to use for any Convolution Effect objects created for this audio processing pipeline. More... | |
Describes various properties of the audio processing pipeline.
Many Phonon API objects that are used by the audio engine need to know how the audio processing pipeline (i.e., your audio engine) applies DSP effects to audio data. This structure describes the key parameters.
| IPLint32 samplingRate |
The sampling rate (in Hz) of any audio to be processed by Phonon.
All audio that is passed to Phonon must use the same sampling rate.** Phonon will output audio at the same sampling rate as its input; no sampling rate conversion will be performed. Supported sampling rates are 24000 Hz, 44100 Hz, and 48000 Hz.
| IPLint32 frameSize |
The number of samples in a single frame of audio.
The value of this parameter should be obtained from your audio engine.
| IPLConvolutionType convolutionType |
The convolution algorithm to use for any Convolution Effect objects created for this audio processing pipeline.


In recent years, Deep Neural Networks have become an essential tool for many machine learning tasks, especially image classification. However, this has given rise to the study of adversarial samples--carefully crafted inputs for a neural network that result in an incorrect classification.
In the spirit of the TensorFlow Playground, we present the Adversarial Playground: a web-based visualization tool to assist users in understanding the differences between common adversarial machine learning techniques. Upon launch, the application starts a lightweight Python webserver hosting a collection of pages related to the visualization. The server-based nature allows remote hosting, but the webserver may be hosted on any computer running TensorFlow.
Usage
We allow multiple types of adversarial attacks, accessible through the top navigation bar:
- Jacobian Saliency Map Approach (JSMA)
- Fast Jacobian Saliency Map Apriori (FJSMA)
- Fast Gradient Sign
The first two approaches implement an L
0-norm method based on the work in
The Limitations of Deep Learning in Adversarial Settings by Papernot et al.
[1]; the first is a direct implementation of their work, while the latter is our own contribution -- an approximation to their algorithm that runs much faster, suitable for a web-based tool. The third evasion approach is an L
∞-based attack, following the common Fast Gradient Sign method. This implementation was directly adapted from the Cleverhans toolkit, also by Papernot et al
[2].
Once on the page for each evasion algorithm, you may select a seed image, adjust the attacking power, and select a target class (for targeted methods). Once you have done so, the evasion algorithm is performed on-demand in real time, and the resulting graphic (and classification likelihoods) are displayed.
About the Attacks
Jacobian Saliency Map Approach (JSMA)
The core idea of this evasion algorithm is to modify pixels from the seed image that produce the greatest impact on the classification of the image. This is done through the use of a
saliency map -- a tool originally used for visualization. After using the saliency map to determine the most impactful pixels, the adversary iteratively modifies pixels that
increase the target classification likelihood while
suppressing the likelihoods for all other classifications. This process is repeated until either the modified image is in the target class, or the L
0 distance between the modified image and seed image exceeds a specified threshold. For more information on the details of the algorithm, we refer the reader to Papernot et al
[1] mentioned above.
The modification to each pixel may take many forms; in this application, the one we apply is to set selected pixels to complete black. (This, and its converse of setting selected pixels to pure white, is a relatively common implementation choice.) Since we are minimizing the L
0 distance, there are very few pixels that are changed in this approach. A typical example is below.
Fast Jacobian Saliency Map Apriori (FJSMA)
A disadvatage of the JSMA is that each iteration requires a combinatorial search of pairs of pixels. A complete slows down the process on the server-side, which can lead to latency for users of this webapp. We approximated the JSMA approach by greedily selecting a small proportion of the pairs of pixels. This enables a faster response time from the server and less waiting for end-users, while still maintaining a comparable evasion rate.
Fast Gradient Sign
In this demonstration, we use an untargeted form of the Fast Gradient Sign method. The core idea of this approach is to compute the gradient of the classifier to find the direction which will change the classification the most, then adjust the entire image by some small amount in that direction. This is good for minimizing the L
∞ norm, but leads to the appearance of random noise covering the entire image. A typical example is as below.
Design Choices
There are a variety of design choices we made that are relevant to the user; please refer to
our paper for more detailed information.
Seed Images
We made an arbitrary selection of 10 seed images, one from each class 0-9, which the user may select to start the attack. We also included a misclassified sample from the "9" class that is resilient to feature squeezing (the sample from mentioned in Xu, et al's paper
[3]). If the application has been configured locally, the selection of samples may be altered by running a simple Python script. (See the
GitHub README for more technical information.)
Client-side rendering
To reduce latency experienced by the user, we've utilized the Plotly.JS JavaScript library to render the images and plots on the client side. However, this does require that you have JavaScript enabled to experience the full features of this software. Please turn off NoScript or similar browser extensions to view the visualizations.


public class SyncContent
extends java.lang.Object
SyncContent
is the applications access point to Parse (our BaaS).
It only contains static methods, and as such it is not intended to be
initialised. Because of a-sync calls and data dependencies throughout the system,
it is not recommended to change call sequence of the different methods.| Modifier and Type | Field and Description |
|---|---|
static boolean |
hasRetrived |
static boolean |
isRetriving |
| Constructor and Description |
|---|
SyncContent() |
| Modifier and Type | Method and Description |
|---|---|
static void |
calculateLastUpdate() |
static void |
fetchCasePatient(android.content.Context context)
Fetches
CasePatient 's from Parse, after lastUpdate, and tries to
put them in to the local database, using TrainingDAO . |
static void |
fetchDataBeforeLogin(android.content.Context context,
SyncCallback callback)
Calls all methods that need to be called prior to login.
|
static void |
fetchExerciseCategories(android.content.Context context)
Fetches
ExerciseCategory from Parse, and ads them to the User singleton. |
static java.util.List<Exercise> |
fetchExercises()
Deprecated.
|
static void |
fetchHandBookArticleAfterUpdate(android.content.Context context)
Fetches
CasePatient from Parse, after lastUpdate, and tries to
put them in to the local database, using HandbookDAO . |
static void |
fetchHandBookCategoryAfterUpdated(android.content.Context context)
Fetches
Category from Parse, after lastUpdate, and tries to
put them in to the local database, using HandbookDAO . |
static void |
fetchQuizesAfterUpdate(android.content.Context context)
Fetches
Quiz from Parse, after lastUpdate, and tries to
put them in to the local database, using TrainingDAO . |
static void |
fetchTrainingProgress()
Fetches
CasePatientStatus from Parse. |
static void |
retriveNewContent(android.content.Context context)
This is
SyncContent main method for retrieving new content. |
static void |
savePatientInBackgroud(Patient p)
Used for storing
Patient to Parse. |
static void |
saveTrainingProgress()
Saves the users progress in the training part of the application, to Parse.
|
static void |
updateExerciseImages(android.content.Context context)
Fetches
ExerciseImage from Parse, after lastUpdate, and tries to
put them in to the local database, using PractiseDAO }. |
static void |
updateExerciseImagesInBackground(android.content.Context context)
Fetches
CasePatient from Parse, after lastUpdate, and tries to
put them in to the local database, using TrainingDAO . |
public static boolean isRetriving
public static boolean hasRetrived
public static void retriveNewContent(android.content.Context context)
SyncContent
main method for retrieving new content.
This method is intended for retrieving all content that is not needed befor,
or during login.public static void fetchCasePatient(android.content.Context context)
CasePatient
's from Parse, after lastUpdate, and tries to
put them in to the local database, using TrainingDAO
.public static void fetchQuizesAfterUpdate(android.content.Context context)
Quiz
from Parse, after lastUpdate, and tries to
put them in to the local database, using TrainingDAO
.public static void fetchHandBookArticleAfterUpdate(android.content.Context context)
CasePatient
from Parse, after lastUpdate, and tries to
put them in to the local database, using HandbookDAO
.public static java.util.List<Exercise> fetchExercises()
public static void updateExerciseImages(android.content.Context context)
ExerciseImage
from Parse, after lastUpdate, and tries to
put them in to the local database, using PractiseDAO
}.public static void updateExerciseImagesInBackground(android.content.Context context)
CasePatient
from Parse, after lastUpdate, and tries to
put them in to the local database, using TrainingDAO
.
This method calls methods that are run on there own threads, and is therefor
run async.public static void fetchExerciseCategories(android.content.Context context)
ExerciseCategory
from Parse, and ads them to the User
singleton.public static void fetchHandBookCategoryAfterUpdated(android.content.Context context)
Category
from Parse, after lastUpdate, and tries to
put them in to the local database, using HandbookDAO
.public static void savePatientInBackgroud(Patient p)
Patient
to Parse.
This is done in a background thread.p
- public static void fetchTrainingProgress()
public static void saveTrainingProgress()
public static void calculateLastUpdate()
public static void fetchDataBeforeLogin(android.content.Context context, SyncCallback callback)
SyncContent
s done
method.context
- callback
-