The Box-Muller Algorithm
Introduction
There are many problems in computational science that can be efficiently solved using stochastic methods; examples include the evaluation of multidimensional integrals, analyzing “what-if” scenarios in control systems, and predicting future events in physics and finance. It is fairly straightforward to generate a list of pseudo-random numbers on a computer. However, these numbers are uniformly distributed. What if we want to generate a string of numbers with a different probability distribution, like a Gaussian distribution (i.e. a bell curve)?
The Box-Muller algorithm can be used to convert two sets of random numbers with uniform distributions into two sets of random numbers with Gaussian distributions. This algorithm does not use any approximation methods. Instead, it makes use of the famous Gaussian integral.
The Gaussian Integral
The Gaussian integral is given by:
\[\begin{equation} \int_{-\infty}^\infty e^{-x^2/2} dx = \sqrt{2\pi} \end{equation}\]If we try to integrate the Gaussian function using traditional methods, we quickly find that the integral does not have a neat solution. However, we can use a little trick to make short work of the integral.
Suppose I have two bell curves, one a function of \(x\) and the other a function of \(y\). We can multiply these two integrals together to get:
\[\begin{align} \left [ \int_{-\infty}^\infty e^{-x^2/2} dx \right ] \left [ \int_{-\infty}^\infty e^{-y^2/2} dy \right ] &= \int_{-\infty}^\infty \int_{-\infty}^\infty e^{-x^2/2} e^{-y^2/2} dx dy\\[0.1cm] &= \int_{-\infty}^\infty \int_{-\infty}^\infty e^{-(x^2 + y^2)/2} dx dy \end{align}\]Since we are analyzing a function in the xy-plane, let’s switch over to polar coordinates. Then, \(r^2 = x^2 + y^2\) and \(dx dy = r dr d\theta\). The limits of integration also change to \(r\) and \(\theta\) rather than \(x\) and \(y\). Now we integrate over all \(r\) values and all \(\theta\) values.
\[\begin{align} \int_{-\infty}^\infty \int_{-\infty}^\infty e^{-(x^2 + y^2)/2} dx dy &= \int_0^{2\pi} \int_0^\infty e^{-r^2/2} r dr d\theta\\[0.1cm] &= 2\pi \int_0^\infty r e^{-r^2/2} dr\\[0.1cm] \end{align}\]Now we can use u-substitution to solve this integral. Let \(u = r^2/2\) and \(du = r dr\). Then:
\[\begin{align} \int_{-\infty}^\infty \int_{-\infty}^\infty e^{-(x^2 + y^2)/2} dx dy &= 2\pi \int_0^\infty r e^{-r^2/2} dr\\[0.1cm] &= 2\pi \int_0^\infty e^{-u} du\\[0.1cm] &= 2\pi \left [ -e^{-u} \right ]_0^\infty\\[0.1cm] &= 2\pi \left [ -e^{-\infty} + e^0 \right ]\\[0.1cm] &= 2\pi \end{align}\]Here’s the cool part. Remember, \(x\) and \(y\) are just variable names. It does not matter if we call each variable \(x\), \(y\), \(z\), or cupcake. All that matters is the integral is equal to \(2\pi\). Let’s just rename variable \(y\) to \(x\). Then:
\[\begin{equation} \left [ \int_{-\infty}^\infty e^{-x^2/2} dx \right ] \left [ \int_{-\infty}^\infty e^{-y^2/2} dy \right ] \Rightarrow \left [ \int_{-\infty}^\infty e^{-x^2/2} dx \right ]^2 = 2\pi \end{equation}\] \[\begin{equation} \int_{-\infty}^\infty e^{-x^2/2} dx = \sqrt{2\pi} \end{equation}\]There we go! We have solved for the total area under a Gaussian curve. Admittedly, I skipped over some of the nuances of why this procedure works, so if you want to know all of the nitty gritty details, read up on Fubini’s theorem.
The Box-Muller Algorithm
Now that we have solved the Gaussian integral, the Box-Muller algorithm is pretty straightforward. Suppose I want to create two sets of random numbers (\(X\) and \(Y\)), each with a probability density function given by a Gaussian integral (\(p(X)\) and \(p(Y)\)). We can use the result above to get expressions for \(p(X)\) and \(p(Y)\):
\[\begin{equation} p(X) = \frac{1}{\sqrt{2\pi}} e^{- X^2 /2 } \end{equation}\] \[\begin{equation} p(Y) = \frac{1}{\sqrt{2\pi}} e^{- Y^2 /2 } \end{equation}\]We can call the total probability density function \(p(X,Y)\). Since \(X\) and \(Y\) are independent sets of numbers:
\[\begin{align} p(X,Y) &= p(X)p(Y)\\[0.1cm] &= \left [ \frac{1}{\sqrt{2\pi}} e^{- X^2 /2 } \right ] \left [ \frac{1}{\sqrt{2\pi}} e^{- Y^2 /2 } \right ]\\[0.1cm] &= \frac{1}{2\pi} e^{- (X^2+Y^2) /2 } \end{align}\]This looks really familiar. Letting \(R^2 = X^2 + Y^2\) gives:
\[\begin{equation} p(X,Y) \Rightarrow p(R,\Theta) = \frac{1}{2\pi} e^{- R^2 /2 } \end{equation}\]And now the interesting part. Suppose I can generate two uniformly distributed sets of numbers between zero and one, not including zero. Call them \(U_1\) and \(U_2\). First, I can transform \(U_1\) and \(U_2\) into two new sets, \(\Theta\) and \(R\) based on the expression above:
\[\begin{equation} U_1 = \frac{\Theta}{2\pi} \Rightarrow \Theta = 2\pi U_1 \end{equation}\] \[\begin{equation} U_2 = e^{-R^2/2} \Rightarrow R = \sqrt{-2ln(U_2)} \end{equation}\]The first expression for \(\Theta\) represents a uniform distribution of numbers over all values from zero to \(2\pi\) (i.e. over all angles). The second expression for \(R\) represents a Gaussian distribution. We can now convert these polar coordinates to cartesian coordinates using \(X = Rcos(\Theta)\), and \(Y = Rsin(\Theta)\):
\[\begin{equation} X = Rcos(\Theta) = \sqrt{-2ln(U_2)} cos(2\pi U_1) \end{equation}\] \[\begin{equation} Y = Rsin(\Theta) = \sqrt{-2ln(U_2)} sin(2\pi U_1) \end{equation}\]As weird as it sounds, \(X\) and \(Y\) both have Gaussian distributions because \(R\) and \(\Theta\) had Gaussian distributions!
We can see the transform in action below. I first genrate 500 pairs of random numbers that are uniformly distributed between zero and one. These 500 points look like a little \(1\times 1\) box in the center of the plot. Then, when you click on the graph, the points change according to the Box-Muller transformation.
Pretty neat!
We can also verify that the transformations produce Gaussian distributions. Below I have plotted four graphs. The one in the upper left shows pairs of uniformly distributed random numbers. The graph in the upper right corner shows the Box-Muller transformation of these points. The two graphs on the bottom show the probability density functions of the original dataset and the transformed dataset. For simplicity, I only show the probability density function along the horizontal axis (\(U_1\)), but the graphs look similar along the vertical axis. You can see that the graph in the upper left hand corner follows a uniform distribution, while the graph in the upper right hand corner follows a Gaussian distribution.
Click the graphs to redraw the points.
Conclusions
There we have it! We can use the Box-Muller transformation to generate random points with a Gaussian distribution. In the next couple of weeks, we will solve the diffusion equation and visualize it with the Box-Muller algorithm.
See you then!


| Based on true events. The Robertson County Sheriff's Department has released footage found on the bodies of the Sawyer family's cell phones and video cameras. What was first thought to be a murder-suicide is now believed to be the return of a centuries-old demon responsible for America's most famous paranormal event. | |
| Genres: | Biography, Horror |
| Director: | |
| Writer: | Cast: | Bell Witch - Marissa Lynne Johnson Lynn - Laura Alexandra Ramos Dana - Cat Alter Lisa - Natalie Burtney Scott - Drew Cash Janette Sawyer - Julia Cearley Priest - M. Steven Felty Brandon Sawyer - Drew Hellenthal Kristi - Desi Ivanova Colby - Benjamin James Michael Sawyer - Ted Jonas Officer Bungalon - Jason Kakebeen Jessica - Danielle Lozeau Chris - James Simenc |


Automate your Jekyll Workflow
AutoJekyll is a tool developed by a graduate of The Iron Yard Orlando's Front End Engineering program. It is an AngularJS web app that allows the user to setup a nice and easy workflow for their Jekyll blog that is hosted through Github. Well technically it can be wired up for a number of different uses and applications but that was the original idea.
The Add A New Post screen allows the user to type in posts in markdown syntax and watch a live preview of their post side by side. This is a great way to begin getting comfortable with typing in markdown because you get real time feedback.
After you have completed your post to your own satisfaction you can make sure you have filled in the proper date for the post, the post title, and the commit message that you would like to appear in your Github repo for this added post. No more having to go into your IDE and terminal just to type, save, `git status`, `git add`, `git commit`, and `git push` back up to the master branch on github. AutoJekyll does all of this work for you straight from the browser through your gh-pages USERNAME.github.io site.


The World Wide Web (WWW) consists basicaly of Hyper Text Markup Language (HTML) documents linked together by hyperlinks. The WWW was invented in the early 1990s, nowadays there are about 30 billion web pages online on the web. All type of files can be found on the web, besides HTML documents (that hold everything together), there are mainly videos, photos and music files online.
The major pieces of the web are: (1) client computers with web browsers, (2) the "cloud" and (3) servers that host files. Browsers make requests via the internet to servers using the HTTP protocol (Hypter Text Transfer Protocoll). The servers respond by files, transfered through the internet and displayed by browsers.
The heart of the web are HTML documents that hold everything together. HTML documents consists of text content, markups (how the content is formated or arranged) and of links (references to other pages or files, e.g multimedia files. Markups are made up of tags, normally in the following structure: <opening tag> content </closing tag>. Tags can also be nested, where the content is another tag inside the tag. There are also void tags that only need opening tags but no closing tags.
These are the most used basic HTML tags:
bold tag:  content  makes tagged content bold
emphasis tag:  content  makes tagged content italic
link tag:  content which is an anchor tag, using the href attribute containing the url to link to.
image tag:
line break tag:
 adds a line break (it's a void tag)
paragraph tag:
content
 adds an invisible box around the paragraphed text
Note about white space in HTML: mltiple white space within text is turned into one single white space.
In HTML, there are different type of elements. Inline elements are used within a specific line of content, e.g. the
 tag. Block elements as the paragraph use an invisible box to define space around it. One other pair of an expample is the inline element of " " opposed to the block element "

When forgetting to set a closing tag, then everything followed by the opening tag is formated by this opening tag. Programmers often say that computers are stupid in the sense that computers only understand clear and error-less instructions (commands) and react very sensitive to typing errors...
The structure of an HTML document is as follows:
<!DOCTYPE HTML>

tagged content

All visible elements of a web page are rectangular, although some elements are invisible (like the 'head' element). Even round forms like circles are in fact rectangular elements (with round edges). The rectancular structure of all the elements of a web page allows to organize content in boxes and easily placing and restructuring content. In structuring a web page it is important to start with the large boxes (the main sections of a page) moving to smaller sized boxes containing different content elements like headlines, images, texts etc.)
HTML and CSS are both "languages". HTML controls the "structure" of a web page. CSS controls the "style" of a page (how it looks). By separating format from content, CSS files help implementing one of the most important principles in programming: avoiding repetition or duplication.
HTML has a tree-like structure with nested tags similar to bigger and smaller branches of a tree, defined by the "DOM" (Document Object Model). When programmers talk about the DOM they are talking about the tree-like structure of a page.
With CSS, cascading style sheets, you can define styles that are applied to every element defined, so that you can avoid repetition. Styles can be defined in different places and are applied in the following order, with definitions further down the list overwriting previous definitions:
"Cascading" means you keep going down into the more and more specific rules until you find the one that most specifically describes the elements. Rules are applied not only to the elements they directly match, but also to all of those elements' child elements. When rules for elements are defined on more than one level, the most specific rule is applied to every element.
Inheritance is a key feature in CSS, a mechanism by which definitions are applied not only to a specific element ("the ancestor"), but also to its nested elements ("the descendants"). Descendant elements may inherit CSS property values from any ancestor element enclosing them.
In CSS you first write a so called "selector", for example a html tag like body or h1 or by defining a class (".class_name". This defines which elements of the page a specific style should apply to. In general it is good to use so called "semantic tags" like h1, h2 etc., pre-defined html tags available for structuring documents in order to define styles for specific types of elements (like h1).
With CSS, style attributes are attached to specific elements. All CSS style attributes can be found in this CSS reference.
There are 3 ways how to include CSS styling in a web page:
Content on a web page is positioned using the box model. A web page consists of different boxes. A box is defined by 4 nested areas or components; for every of these 4 components the size or width can be defined:
Software development follows these three steps over and over again:
But how to get to the first code from your design mockup? You should follow these steps:
It is very important to verify the correctness of the produced HTML and CSS code. You can do that using the these validators:


{% extends "base.html" %} {% import "bootstrap/wtf.html" as wtf %} {% block content %}
Name:
{{user.first_name}} {{user.last_name}}
Education:
{{user.education}}
Employment:
{{user.employment}}
Favorite song:
{{user.music}}
Favorite movie:
{{user.movie}}
Nationality:
{{user.nationality}}
Birthday:
{{user.birthday}}


The compare view allows the joined view of two (or more) annotated documents.
The compare view shows the document in text view, and the annotated mentions underlined. Colors, however, do not signal different entities, as in the regular annotation view. Instead, each annotator is represented by a color, and all annotations that are not in agreement are underlined by the annotators color. Annotated spans that are marked by all annotators are underlined in gray.
The panel on the right shows settings and numbers about the agreement (see screenshot below). On the top, you find information about the currently used mode. Below that, each annotators is presented individually. On the bottom, you see some agreement statistics.
Information about annotators: For annotators, the view shows the number of annotated mentions and entities, as well as the position. Position is the last annotated mention (thus, it roughly corresponds to where in the document the annotator is).
Modes: In version 2.0, two comparison modes are supported: By default, the comparison only takes the span into account. I.e., two mentions are considered equal, if they cover the same words, irrespective of the entity they refer to. The alternative mode can be activated via the settings menu ("Compare by entity name"). If activated, two mentions are only considered equal if they cover the same span and the names of the entities they refer to are also equal.


{% with activity.object.target as target %} {% get_social_accounts target as accounts %} {{ activity.actor.first_name }} followed {{ target.username }} {% endwith %}


How to register to vote in the 2019 General Election
It’s déjà vu all over again as we ready ourselves for the third General Election in four years.
Prime Minister Boris Johnson previously said he wanted the vote – which is scheduled for 12 December – to take place because there’s a need for a ‘new and revitalised’ Parliament to see Brexit through.
As the election approaches, so too does the deadline to register to vote in time to cast your ballot.
How to register to vote in the upcoming election
You’ll need to register to vote if you are a first-time voter or if you have moved house since the last time you voted.
Registering to vote takes minutes and all you need to do is go to the Government’s website.
You must be over 16 to register to vote, but you won’t actually be able to vote until you turn 18. You must also be either a UK citizen or an Irish, Commonwealth or EU citizen with a permanent address in the UK.
Advertisement Advertisement
When you register, you’ll be prompted to fill in your National Insurance number – however you can still register without it – as well as where you live, what your nationality is and your date of birth.
If you don’t have a fixed address, you can still register if you fill out a form called ‘Declaration of local connection’, which you can also find on the government’s website.
You’ll need to return the form to your electoral registration office which you can find by going to yourvotematters.co.uk.
The deadline to register to vote is midnight on Tuesday, 26 November.
That means, at the time this was written, you have four days left to register if you haven’t done so already.
If you want to register for a postal vote, your application must reach your electoral registration office 12 working days before the general election date – in this case, that’s Monday 25 November.
Advertisement Advertisement
If you live in Northern Ireland however, the postal vote application deadline was 21 November.


Here is a more recent photo of fordy's plant.
There are more friends
good question
to be honest I dont know
Once a week
a bit
great question
probably john or ross
Update: I was out for a week and john watered it
I'm not really sure
yes, it has four stuffed animal friends, a cat, a corgi, a gnu, and a large parrot


2 Samuel 22:16
And the channels of the sea appeared, the foundations of the world were discovered, at the rebuking of the LORD, at the blast of the breath of his nostrils.


Negros Occidental imposes permanent ban on pork from Luzon
The ordinance will cover live pigs, boar semen, pork and pork products originating from, manufactured, and processed in Luzon and in African swine fever-affected countries and in other areas
by Marchel EspinaSubscribe
Email Address
Newsletters
- Glenda Gloria's Take this Tuesday
- Huddle by Miriam Grace Go
- The Newsbreak Agenda by Chay Hofileña
- Sometimes, all you need is video by Lilibeth Frondoso


| > The Unit Test Framework > Testing tools > Floating-point comparison algorithms |
本章数学性太强，翻译很差强人意，希望哪位大牛能够指正 -- 译者注
In most cases it is unreasonable to use an operator==(...)
for a floating-point values equality check.
The simple, absolute value comparison based, solution for a floating-point values u
,
v
and a tolerance :
在大多数情况下，不应用使用 operator==(...)
来检查浮点数是否相等。
简单的，基于绝对值比较的，应用于浮点数值 u
、v
和限度的解决方案：
does not produce expected results in many circumstances - specifically for very small or very big values (See
[Squassabia] for examples). The UTF implements floating-point comparison algorithm that is
based on the more confident solution first presented in [KnuthII]:
在很多情况下不能产生期望的结果 - 尤其是对于非常小或非常大的值 (例子参见[Squassabia])。
 The relationship defined by inequations
(2) is stronger
that the relationship defined by inequations (3)
(i.e. (2)
(3)). Because of the multiplication in the right side
of inequations, that can cause an unwanted underflow condition, the implementation is using modified version of the
inequations (2) and
(3) where all underflow, overflow conditions can be
guarded safely:
两种关系都是可交换的，但不是可传递的。
不等式 (2) 定义的关系强于不等式 (3) 定义的关系
(也就是 (2) (3))。
因为不等式右边的乘法可能会引起不期望的下溢条件，
实现使用修改版的不等式 (2) 和 (3)，
所有下溢，上溢的条件都被安全地监视：
Checks based on equations (4) and
(5) are implemented by two predicates with
alternative interfaces: binary predicate close_at_tolerance
[8] and predicate with four arguments
check_is_close
[9].
基于不等式 (4) 和 (5) 的检查由可选接口的两个断言实现：
二元谓词 close_at_tolerance
[8]
和接受四个参数的谓词 check_is_close
[9]。
While equations (4) and
(5) in general are preferred for the general floating
point comparison check over equation (1), they are
unusable for the test on closeness to zero. The later check is still might be useful in some cases and the UTF
implements an algorithm based on equation (1) in
binary predicate check_is_small
[10].
相对于等式 (1)，虽然在通常情况下，不等式 (4) 和 (5) 是通用浮点数比较检查的首先，但在测试接近于 0 的时候是不安全的。
前一个检查在某些情况下仍然是有用的，基于等式 (1) UTF 实现了二元谓词 check_is_small
[10]。
On top of the generic, flexible predicates the UTF implements macro based family of tools
BOOST_CHECK_CLOSE
and BOOST_CHECK_SMALL
. These tools limit the check
flexibility to strong-only checks, but automate failed check arguments reporting.
在通用、可伸缩的谓词基础上，UTF 实现了基于宏的工具族 BOOST_CHECK_CLOSE
和 BOOST_CHECK_SMALL
。
这些工具将检查的可伸缩性限制为只关注健壮性的检查，但自动报告失败的检查参数。
In case of absence of domain specific requirements the value of tolerance can be chosen as a sum of the predicted
upper limits for "relative rounding errors" of compared values. The "rounding" is the operation by which a real
value 'x' is represented in a floating-point format with 'p' binary digits (bits) as the floating-point value 'X'.
The "relative rounding error" is the difference between the real and the floating point values in relation to real
value: |x-X|/|x|. The discrepancy between real and floating point value may be caused by several reasons:
假设存在领域特定需求，限度的值可被选为要比较值的 "相对舍入误差" 的可预测上限的总和。
"舍入" 是将实数 'x' 被以浮点数格式用 'p' 二进制进 (位) 表示的浮点数 'X'。(???)
"相对舍入误差" 是实数和浮点数值在关系 |x-X|/|x| 的差值。
实数和浮点数值之间的差异可能由如下原因引起：
The first two operations proved to have a relative rounding error that does not exceed
"machine epsilon value" for the appropriate floating point type (represented by
std::numeric_limits
<FPT>::epsilon()). Conversion to binary presentation, sadly, does
not have such requirement. So we can't assume that float 1.1 is close to real 1.1 with tolerance
"machine epsilon value" for float (though for 11./10 we can). Non arithmetic operations either do not have a
predicted upper limit relative rounding errors. Note that both arithmetic and non-arithmetic operations might also
produce others "non-rounding" errors, such as underflow/overflow, division-by-zero or 'operation errors'.
前两个操作被证明有不超过相应浮点数类型 "机器精度值" (用 std::numeric_limits
<FPT>::epsilon() 表示) 的相对舍入误差。
不幸的是，转换为二进制表示，没有这样的保证。
所以我们不能假定浮点数 1.1 在浮点数 "机器精度值" 的限度上接近实数 1.1 (虽然对于 11./10 我们可以这么说)。
非算术操作也没有可预料上限的相对舍入误差。
注意，算术操作和非算术操作都可能产生其它 "非舍入" 误差，例如下溢 / 上溢，除 0，或 '操作误差'。
All theorems about the upper limit of a rounding error, including that of epsilon, refer only to
the 'rounding' operation, nothing more. This means that the 'operation error', that is, the error incurred by the
operation itself, besides rounding, isn't considered. In order for numerical software to be able to actually
predict error bounds, the IEEE754 standard requires arithmetic operations to be 'correctly or exactly rounded'.
That is, it is required that the internal computation of a given operation be such that the floating point result
is the exact result rounded to the number of working bits. In other words, it is required that the computation used
by the operation itself doesn't introduce any additional errors. The IEEE754 standard does not require same behavior
from most non-arithmetic operation. The underflow/overflow and division-by-zero errors may cause rounding errors
with unpredictable upper limits.
关于舍入误差上限，包括精度的所有理论，都只考虑 '舍入' 操作，不考虑其它。
这意味着 '操作误差'，即操作本身产生的误差，包括舍入，并没有考虑在内。
对于数值计算软件，为了得到实际可预料的误差范围，IEEE754 标准要求算术操作是 '正确或精确舍入' 的。
也就是说，它要求给定操作的内部计算的浮点结果是工作位的精确四舍五入结果。
换句话说，要求计算本身的操作不引入额外的误差。IEEE754 标准并不要求大多数非算术操作有相同的行为。
下溢/上溢和除 0 错误可能引起不可预料上限的舍入误差。
At last be aware that epsilon rules are not transitive. In other words combination of two
arithmetic operations may produce rounding error that significantly exceeds 2 epsilon. All
in all there are no generic rules on how to select the tolerance and users need to apply common sense and domain/
problem specific knowledge to decide on tolerance value.
最后注意精度原则不是传递的。换句话说，两个操作操作的组合可能会产生显著超过 2 倍精度的误差。
总之，没有如何选择限度的通用准则，用户需要根据通用认识和领域 / 问题特定知识决定限度值。
To simplify things in most usage cases latest version of algorithm below opted to use percentage values for
tolerance specification (instead of fractions of related values). In other words now you use it to check that
difference between two values does not exceed x percent.
为了在多数情况下简化问题，下面最后一片算法选择使用百分比值作为限度 (而不是相关数值的分数)。
换句话说，你现在使用它检查两个值差距不超过 x 百分比。
For more reading about floating-point comparison see references below.
更多关于浮点数比较的著作请参见下面的参考。
[KnuthII] The art of computer programming (vol II). Copyright © 1998 Addison-Wesley Longman, Inc.. 0-201-89684-2. Addison-Wesley Professional; 3 edition.
[Kulisch] Rounding near zero. Advanced Arithmetic for the Digital Computer. Copyright © 2002 Springer, Inc.. 0-201-89684-2. Springer; 1 edition.
[Squassabia] Comparing Floats: How To Determine if Floating Quantities Are Close Enough Once a Tolerance Has Been Reached. C++ Report. March 2000. .
[Goldberg] “What Every Computer Scientist Should Know About Floating-Point Arithmetic”. Copyright © 1991 Association for Computing Machinery, Inc.. 150-230. Computing Surveys. March. .
[Langlois] From Rounding Error Estimation to Automatic Correction with Automatic Differentiation. Copyright © 2000. 0249-6399.


Dinosaur * 1/2 (out of * * * * )
Directed by Ralph Zondag, Eric Leighton. Voices: D.B. Sweeney, Julianna Margulies, Ossie Davis, Alfre Woodard, Max Casella, Samuel E. Wright, Peter Siragusa, Joan Plowright, Della Reese. 2000 - 82 minutes Rated PG (for dinosaur violence). Reviewed by Dustin Putman, May 20, 2000.
Last November, audiences who went to see "Toy Story 2" were treated to an advanced look at this summer's tentpole Disney animated feature, "Dinosaur." A beautiful and majestic peek at the world when dinosaurs ruled the Earth, the trailer was awe-inspiring not only because of its revolutionary step forward in visual effects (placing lifelike computer-generated characters in largely live-action settings), but also because, for once, it seemed as if Disney was growing up themselves. It should have been self-evident that the studio had not matured that much, as "Dinosaur" misleadingly appeared to be dialogue-free and a fairly realistic glimpse into the Jurassic era. Instead, what Disney chose to do with this supposed-to-be-insurrectionary family film is they not only gave the dinosaur characters' voices, but they implanted them in a story that has been recycled in practically every other animated Disney movie ever made, but with only one-tenth of the charm and entertainment value. The animation may be the most realistic created, but that is where the compliments stop for the abysmally featherbrained "Dinosaur."
The sweeping prologue (the only section that spares us stock character voices), in which an Iguadon egg becomes misplaced from its mother's nest, and through a series of circumstances, ends its journey on an island primarily populated by Lemurs, tiny, kind, monkey-like creatures, is as imaginative as this picture gets. When they egg hatches, there is a moment of pause by the Lemurs due to the Iguadon's nature to be a meat-eater, but soon they have adopted him and named him Aladar (voiced by D.B. Sweeney). Time passes and just as Aladar has grown a little older, and a lot larger, tragedy strikes.  While trekking through a wide, desolate expansion of dry, open ground, Aladar and his four Lemur family members join a group of dinosaurs traveling to a green, more healthy and peaceful place to live, headed by the gruff Kron (Samuel E. Wright).
"Dinosaur" has too many problems to count, but one of its biggest is that the story, written by John Harrison and Robert Nelson Jacobs, was never fully thought out. In fact, there is very little in the way of a plot to speak of, and, aside from having to ward off two violent T-Rex-lookalike Carnotaurs, no true dilemmas to overcome. The film almost immediately shoots down the hopeful notion that it would present a serious look at the alleged nature of dinosaurs, and their interactions with the different species', opting to tell an awkward PG-rated kiddie flick that undiscriminating children will enjoy, but will likely leave all other viewers out in the cold.
There are certain elements that define the quintessential animated Disney film. They are usually inhabited with memorable characters; a rightfully nasty and original villain; have a great deal of heart; are filled with musical numbers that the characters carry out in all their glory; and are superbly animated. "Dinosaur" does away with the musical numbers, which is a somewhat amiable change of pace, but bars the picture from having any other defining or noteworthy qualities outside of its technical skill in the animation arena. Meanwhile, "Dinosaur" is wholly devoid of the three former Disney attributes.
Unlike Minnie Driver in 1999's far superior "Tarzan" or Demi Moore in 1996's "The Hunchback of Notre Dame," the voice work, supplied by several well-known actors (i.e. Julianna Margulies, Joan Plowright, Alfre Woodard, etc.), is forgettable, and just like the ho-hum direction by Ralph Zondag and Eric Leighton, their hearts simply do not seem into this project. The writing does not help, as the characters are purely disposable and have few defining personality features to tell them apart, and, most importantly, remember them once the lights go up.
At 82 minutes, almost ten of which are taken up by the end credits, "Dinosaur" is almost over before it begins, and good riddance. A crushing bore in the story and character department, and not taking full advantage of its grandiose vision (save for the astounding opening and the meteor shower sequence), "Dinosaur" is a distressingly lifeless concoction. The fact that it holds so much promise makes the outcome all the more calamitous.
- Copyright 2000 by Dustin Putman Http://www.young-hollywood.com Http://www.atnzone.com
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Magnolia is a large genus that contains over 200 flowering plant species...
Some magnolias, such as Magnolia stellata and Magnolia soulangeana, flower quite early in the spring before the leaves open...


Raw notes... Some of this is factual, but a lot of it is my own personal opinion. Key point: no wrong way to play so long as you enjoy it! Make sure you understand the leveling algorithm (uesp link) or this won't make sense.
The most important and impactful decision is the first one: how important is your character's potency? Naturally everyone wants to maximize their character's potency, but because of the "Leveling Problem", maximizing potency requires careful planning and work. Like all things in Oblivion, this boils down to a choice: the more you want to maximize your character's potency, the harder you will have to work at it.
The first thing that will determine your character's final potency is how you want to deal with leveling. Because the monsters, quests, and gear in Oblivion are fixed for each level, how you choose to handle your character's leveling will have a substantial impact on his/her final potency.
One way you can play Oblivion is by ignoring the "Leveling Problem" entirely. Just choose what feels right and do whatever you want in-game. If your character's potency drops compared to the monsters' potency, you don't care. And if you get stuck, you can always reduce the game's difficulty.
This approach gives the highest amount of freedom, but is most likely to yield a low potency character.
As discussed in UESP's Under Leveling page, the concept of Under Leveling is to rarely/never sleep which keeps you near level 1. Because the monsters' potency remains fixed while yours increases via skill ups, your character ends up being comparatively much more potent then all monsters.
The big down side to this is that you cannot access anything that has a level requirement. This includes many quests and their associated powerful rewards. Also, this tends to make obtaining cash harder, which makes the high fixed prices of bigger items (e.g. houses and housing upgrades) somewhat painful.
This approach gives a high amount of freedom and will result in a character with a comparatively high potency, but you will miss out on some aspects of the overall game.
Power leveling is what the most hard-core players do. Not only is every attribute and skill planned out before the character has been created, but every skill up is done in a deliberate and controlled fashion. Often power levelers do nothing for many levels except raise their skills (e.g. jumping in place for Acrobatics, summoning the same Zombie over and over for Conjuration, etc).
Note that power levelers can engage in some small parts of the game, but they do so only to further their leveling. A common example would be gaining access to Spellmaking and Enchancement altars (say, by doing the Mage's Guild's Recommendation quests). What makes someone a power leveler is that they level up first and then play the rest of the game second.
This approach gives the least amount of freedom, but will yield the highest possible character potency.
The majority of players are in between ignoring the "Leveling Problem" and Power Leveling. If you completely ignore the "Leveling Problem", you'll probably end up reducing the game's difficulty at some point and some people feel that's akin to cheating. OTOH, even if you want to power level, it's very difficult to do that the first time you play the game.
The middle ground, as I'm defining it, is a hybrid where you want to do your best to plan for and overcome the "Leveling Problem", but you also want to minimize the time spent power leveling.  Hybrid players start each level by doing whatever they want and then do a few power leveling skill ups to actually complete the level with maximum potency.
This approach gives a meidum amount of freedom, but can yield a highly potent character. FWIW, I used a Hybrid Leveling approach with Nullis and have been very pleased with how it has gone.
Before deciding how to deal with your character's Luck, you need to understand how Luck impacts your character's potency. UESP's Luck page has all of the details, but for planning purposes, Luck has two key aspects:
You don't choose The Thief birthsign nor do you make Luck a Favored Attribute of a Custom Class. Luck starts at 50 and is not leveled up until all other attributes have been maximized.
This is the simplest way to handle Luck, but your character never reaps any benefits from Luck, arguably making your character less potent.
In Luck Last leveling (aka 5/5/5 leveling -- meaning 3 attributes are raised 5 points each), you care about Luck some, but you care more about the other attributes.
Luck First leveling (aka 5/5/1 leveling - meaning 2 attributes are raised 5 points and Luck is raised 1) is used when you value Luck above all other attributes. Every level you increase Luck by 1 until it is maximized. You probably want to select The Thief birthsign and make Luck a Favored Attribute of a Custom Class to reduce the number of Luck level ups necessary to its minimum of 35 levels.
You have to sacrifice your birthsign and one of the two Favored Attributes of your class to Luck, Because Luck has no skills that require increasing for a bonus, levels will come a bit quicker than 5/5/5 leveling. every level up only needs 10 major skill points and 10 minor skills points,
Raw notes...
Raw notes... Careful with all 3 skills for an attribute being major. Major skills that you will never use are best if they can be easily increased; e.g. you can self cast spells from any magic discipline or increase Block by letting the Battlehorn Castle trainer beat on you, etc.
Raw notes... Impact of no enchanting/spellmaking altar access. Fences and lockpicks and not being in the Theives Guild. Needing a bed (never worth buying a house for one esp. considering guilds).


Joe Swash fuels Stacey Solomon secret marriage rumours as he flashes gold ring
Joe Swash and Stacey Solomon have just returned from the Maldives, where fans were convinced they'd secretly got married - and Joe has only fuelled the rumours by wearing what appears to be a wedding band
by Emmeline SaundersJoe Swash has added more fuel to the rumours he and Stacey Solomon secretly got married during their romantic family holiday to the Maldives - by flashing what seems to be a wedding ring.
The former I'm A Celebrity star was spotted on his way out of Dancing On Ice training in Essex, where he's been taking part in gruelling practice sessions with pro skater Alexandra Schauman.
Dad of two Joe, 37, grinned as he spotted the cameras, before raising up his left hand to flash the gold band sitting on his ring finger.
Joe kept tight-lipped as he left the ice-rink, dressed casually in a black tracksuit and matching cap.
It came after he, Stacey, her sons Zachary, 11, and Leighton, seven, plus their baby son Rex jetted out to the Maldives for a sun-drenched romantic trip.
While they were out there, Stacey shared a family picture of them all that sparked secret wedding rumours - because all the boys were wearing formal suits.
Her eldest sons were in crisp beige linen jackets with white ties shirts and ties, while baby Rex beamed in his little linen rompersuit and bow-tie.
Stacey and Joe were much more casually dressed, with Stacey in a flowing blue tunic dress and Joe in a matching cornflower blue shirt and beige shorts.
Fans were convinced the formal outfits were a nod to Joe and Stacey's wedding ceremony, congratulating the two on tying the knot.
But the couple have since revealed the truth behind the speculation.
Taking to Instagram yesterday, Stacey said: "Hey, we just need to clear up.
"Lots of people had messaged and commented to say they thought we got married. I'm only just reading through them all now and I'm like, 'Oh my god'."
"We didn't get married," Joe interjected.
Stacey then confirmed: "We wouldn't secretly get married anyway because I'd be so over the moon, I'd tell everyone.
"All our families would be there, my family and Joe's family."
Joe also cleared up the confusion about his ring, saying it definitely wasn't a hint at his marital status.
"The rings I'm wearing are from my dad, he passed away when I was a kid so I wear them for luck," he explained.
Stacey cheekily added that she had been expecting Joe to get down on bended knee considering what a romantic hotspot it is.
"Secret gutted myself, would've been a great place for a proposal."
Next time, Stacey!


Easily generate alerts on the fly with a custom Smart Alerts plugin. Click any of the buttons below to generate an alert.
All you need to do is to init the plugin and generate a new alert on any event (e.g. click or submit):
var smartAlerts = new SmartAlerts(); $("button").click(functon() { smartAlerts.generate("info", "This is an info alert!"); });
This plugin requires jquery.smartAlerts.js and jquery.smartAlerts.css included.


By setting a few CSS properties, and giving the viewportMargin a value of Infinity, CodeMirror can be made to automatically resize to fit its content.
viewportMargin
Infinity


{% extends "base.html" %} {% block page_title %}Candidates for Election {{ title }}{% endblock %} {% block styles_head %} {% endblock styles_head %} {% block javascript_head %} {% if ads_enabled %} {% endif %} {% endblock javascript_head %} {% block content %}
{% if election_active == "ACTIVE" %} There are two ways for your constituents to vote for the {{ title }}. You can print out barcodes using the link below, and place the barcodes next to the items being voted on. When the barcodes are scanned using a mobile phone, they'll open the user's browser to a web site where they can vote.
This election has ended.
{% if winners|length == 1 %}{{ winners[0].name }} won!
{% else %}The following candidates tied: {% for winner in winners %}{{ winner.name }}{% if not loop.last %}, {% endif %}{% endfor %}
{% endif %} {% else %}This election has not started yet.
{% endif %}


Matheus Pereira dos Santos
Resume
As a Computer Engineering student, intern of web development in an Startup, working with HTML, Css and Javascript.
Love soccer and play video games.
Education
- High school graduation
- Technical training in Computer maintenance
- Computer Engineering Student
Other Links


|
JNIPort for Dolphin Smalltalk |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
Back to Goodies |
The Problems with ThreadsThis section is about the problems caused by the mismatch between the ways that the Java runtime and Dolphin use and understand operating system threads. The discussion may be quite off-putting, since it describes various ways of getting into trouble without expecting to. Of course, you can do that with any threaded code, but the Java/Dolphin mix is particularly hard to get right. There's nothing much more I can do to help with that; I've tried to make this section as comprehensible as I can, but it's still not an easy read. I offer the following guideline:
OverviewThe Java runtime from Sun implements Java threads as Windows threads. Other JVMs for Windows either do the same, or multiplex several Java threads onto each OS thread (I believe that both the IBM and BEA runtimes do this, or can be configured to do so). In either case the Java runtime is thread-intensive and is thread-aware.
Dolphin, on the other hand, executes all Smalltalk code in just one OS thread. All the
Smalltalk With a good deal of messing around, some determined turning of blind eyes to theoretical problems, and quite a bit of care, it is possible to reconcile these two systems. Almost all of the problems revolve around callbacks from the Java runtime into Dolphin. (The other problems are described below.) The Java runtime calls Dolphin code in two ways: when a Java “native method” is implemented by Dolphin code, and when the Java runtime's “hook” functions are implemented by Dolphin external callbacks. Later sub-sections go into more details, but the problem, and the general strategy for avoiding it, are the same in both cases. The General Problem
The problem is that the callback into Dolphin can be made from an OS thread that is not the one
that Dolphin uses for running Smalltalk code (call it the Smalltalk thread).
In an ideal world Dolphin would be able to execute Smalltalk code on any OS thread, in which
case these issues would vanish, but this is not an ideal world. Fortunately, Dolphin does have
a basic ability to handle such calls. When the Dolphin VM finds that one of its
Unfortunately that can lead to deadlocks. One way is because Dolphin cannot service callbacks while the Smalltalk thread is executing Java code:
The threads are now deadlocked; each waiting for the other.
Another way to create a deadlock is if the a background thread takes out a lock, and
then invokes an
The threads are deadlocked. A related, but not identical, source of deadlocks is:
The General “Solution”The technique that JNIPort uses for dealing with these case is to decouple the two threads wherever possible. It requires a queue and an additional thread. When the background thread wants to issue a callback, it does not call into Dolphin directly. Instead it places the request onto a queue, and then immediately returns to its caller. The additional thread, the demon thread, has been sleeping waiting for the queue to become non-empty. When it wakes up, it sees the notification, removes it from the queue and then calls back into Dolphin. The demon thread will be blocked at this point, waiting for Dolphin to finish handling the callback, but the original background thread has not had to wait, and so the deadlocks are avoided. Naturally, this technique can only be used when the caller is not interested in the answer to the call. There is an additional complication. If the code in the Java runtime that issues the call was running on the Smalltalk thread (because it had been invoked from Dolphin via JNI), then it should issue the callback directly, rather than putting it on the queue. For pure notifications (where no answer is wanted) side-stepping the queue is just avoiding a needless inefficiency. However if an answer is needed, then the caller cannot use the queue or else a different deadlock would occur, as follows:
Hook functions
The Java runtime has three hook functions. These are pointers to functions that
will be invoked by the runtime to allow client code to monitor the state of the JVM. In particular
this is used for the runtime's debugging/logging output, such as the trace of loaded classes
produced if the
A particularly common way that the hook functions can cause deadlocks is through the
Java logging/tracing feature. One example is Swing. When Swing is starting up, as the
first window is displayed, Swing starts a new Java thread to handle user-interactions.
So, in the first call to display a window, something like
The JNI Helper library is an external DLL that provides wrapper functions for external callbacks. The wrapper functions use the queue/demon approach internally to ensure that threads other than the Smalltalk thread are never blocked waiting for Dolphin to handle the notification. With the JNI Helper, as far as I know, all the deadlocks arising from logging are avoided. Native Methods, Notifications, and RequestsThe other way that a Java runtime can invoke code in Dolphin is via Java's “native methods”. A native method is a Java method that is declared but not defined in the Java code, instead an implementation is provided by external (to the JVM) code. The implementation can be provided by using JNI to set a pointer to a handler function (it can also be provided by a DLL but that is not relevant to JNIPort). As in the case of hooks, Dolphin's external callback feature can be used to create a “function pointer” that will actually cause Smalltalk code to be executed. But, again, there is a risk of deadlocks. JNIPort includes a Java library that uses the queue/demon approach to avoid or reduce the risk. In this case JNIPort can't eliminate the risk, since sometimes the caller does need to wait for an answer. For that reason Java callbacks are broken down into Notifications and Requests. Both go via the queue, but only the latter wait for an answer. See Callbacks for more information on how to use them. There is an additional reason for using the queue/demon approach for Java callbacks. It is unrelated to deadlocks, but is caused by a quirk of the way that JNI works with threads.
All normal JNI operations are invoked via a pointer to a In fact, whenever the Java runtime calls a native method, it creates new JNIEnv that will be valid only for the calling thread, and only until the callback returns. (The main point of this seems to be a half-baked attempt to make managing references to Java objects from C code slightly automatic.) That doesn't affect this discussion but does cause an additional problem that is described below.
The problem is that it makes it impossible to pass references to Java objects from Java to
Smalltalk!
The reason is as follows. Suppose that some Dolphin
Fortunately a slight modification to the queue/demon approach provides a way around the problem.
In JNIPort you are not encouraged to declare native methods and create your own
The Notifications and Requests are Java objects that hold a reference to the originator of the request, a parameter object (which, of course, may be an array), and a “tag” object that is used to identify the Smalltalk handler code. The mapping from tag object to handlers is held by the callback registry as described in Callbacks. The details of the interaction are quite complicated, and unfortunately have some unintuitive consequences for the order of events. To start with the simplest case, here's what happens when Java code, that happens to be running on the Smalltalk thread, sends a notification to Smalltalk:
The case where an answer is required is very similar. The differences are only that the Java code creates a Request object instead of a Notification; that the callback registry records the answer from the handler in the request object; and that the Java code (presumably) reads the answer and makes some use of it. The next case is slightly more complicated. If a notification is issued from a thread other than the Smalltalk thread, then there are three threads that are actively involved, as follows:
By the way, I'm glossing over the details of how various race conditions are avoided. They don't affect the overall design; see the code if you're interested. The next case is more complicated again. If a request is issued from a thread other than the Smalltalk thread, then it must wait for a reply:
One thing to note is that, for Notifications and Requests sent from the Smalltalk thread, the caller does not return until all pending callbacks have been handled. So, if there are a number of background threads submitting callbacks at the same time, the original Java code may be blocked until there happens to be a pause long enough for Dolphin to empty the queue. Another thing to note is that this scheme does not protect against all deadlocks. Notifications should be deadlock free, but if you are using Callbacks then you should ensure that you do not hold any locks on Java objects while you are waiting for the response. The last important point is that, as mentioned above, if the Smalltalk thread is not executing Smalltalk, then it is not available to handle callbacks. In particular code like the following can work unexpectedly:
If that method is called from Smalltalk, then it will block Smalltalk until it returns, so no callbacks can be handled until it does. If any of the worker threads issue Notifications, then Dolphin will not see them until after all the threads have died. If any of them makes a callback Requests then it will deadlock — the thread will be waiting for Dolphin to handle the callback, but the Smalltalk thread will still be blocked waiting for all the threads to complete. FinalisationJNIPort releases references to Java objects by finalisation. If you read the “guideline” at the beginning of this section, then you may be struck by the thought that the Dolphin finaliser Process will run even if the rest of Dolphin is passively handling callbacks from Java. The impression is correct, and the way that references to Java objects are cleared by finalisation does break the guideline. The problem is really more serious than just not adhering to an informal guideline. JNI specifies that “local” JNI references must be released by the same JNIEnv as created them. What's more, it insists (a severe and pointless restriction, in my view) that they cannot be released at all if there's another JNIEnv active at the time for the running thread. That means that finalisation cannot feasibly be used to clear local references unless JNIPort as a whole can be sure that only one JNIEnv is ever used.
That condition can be met only if no Java callbacks are ever used (the hook functions don't
cause a problem here). That is the reason that there are two slightly different subclasses
of the Smalltalk class Other ProblemsLastly, there are two race conditions that — as far as I can see — cannot feasibly be removed. In both cases there is a very small time period during which, if the luck were against you, JNIPort would use the wrong JNIEnv for some operation. It would probably be possible to remove the race conditions by adding yet more complexity, and putting Semaphore protection around every access to the JNIEnv. That would cause a considerable increase in the already large overhead involved in using JNIPort. Since I have not been able to produce any scenario where the problems manifest in practice, I have not taken that step. Possibly a future version of JNIPort will have a configurable policy of some sort rather than hard-wiring the decision.
The first case applies during a callback. As the callback is processed, i.e. when
the Dolphin VM invokes the
The other case is about exception checking of JNI calls, it is applicable even
if callbacks are not enabled. JNI uses a per-JNIEnv (and, therefore, thread-local)
flag to say 'an exception has been thrown from Java', and all JNI calls should check
the flag (all subsequent JNI calls will fail until it is cleared). Since all Dolphin
|
Copyright © Chris Uppal, 2003-2005
Java, JNI (probably), JVM (possibly), and God knows what else, are trademarks of Sun Microsystems, Inc.


--- layout: archive title: Zulip Chat Archive permalink: /stream/113488-general/topic/euclidean.20domains.20PR.html ---
I think https://github.com/leanprover/mathlib/pull/78 is at this point waiting either to be merged or for further comments.
I hope eventually it can be merged, so I can tick off the last box for Louis' summer project.
I merged Louis' PR. There are some minor things that I notice, but it's best to just let that stuff evolve inside mathlib, it's gone through the ringer already and it came out nicely
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


[§449-1.8] Confidential portion of application or records. Information contained in any application or record shall be made available to the public unless that information may be withheld from public disclosure by the commissioner under chapter 92F. [L 2001, c 184, pt of §1]


The Milky Way is huge. Best estimates put it at around 100,000 light years across and it might be even a bit larger. There are, by most estimates, about 100 billion planets in our galaxy. Even if we estimate that only 1% of them are Earth-like planets, that’s still about a billion planets possibly capable of supporting life as we know it. But they are so very far apart.
Here’s an analogy of the distances involved: if the Sun was about the size of a basketball, placed right on the edge of the eastern coastline of Florida, and the Earth a little smaller than the size of a BB placed about 93 feet away from the basketball-Sun, then our closest stellar neighbor, the Alpha Centauri system, would be somewhere in California. (real distance about 2500 miles) Look carefully at that little BB. Imagine microscopic bacteria crawling all over it.  Now turn toward California and imagine those microscopic organisms trying to reach California, either with spaceships or radio. And everything in between those two points, the BB in Florida and the Centauri system in California, is empty. Imagine trying to call California. Just saying hello would take four years for the message to reach Cal. The answer would take another four years to come back.
When astronomers peer out into the sky, looking for new planets, it takes a very specialized form of astronomy to determine if the star even has planets. Never mind the techniques; we’ve found only a handful of Earth-like planets so far and even those are pretty iffy. Yes, it’s possible that another civilization like ours—or even really different—may be trying to do the same thing. But: space is vast. Bigger than we can conceive, even with the analogy I mentioned. We could be looking right at a star with a planet that has life similar to ours and we’d never know unless they happened to be looking at us and signaled us at exactly the same time we happened to be looking at them. What are the odds?
Pretty bad, actually. The Drake equation—see the other answers on this thread—indicates that there should be many civilizations in this galaxy. But, for them to contact us, they’d have to be extremely advanced. If they are, then they wouldn’t necessarily want to talk to us anyway. Do you want to talk to those microscopic bacteria crawling all over that BB? It would be a rather boring conversation I think.
The chances are pretty good that there are other inhabited planets with fairly advanced civilizations in the Milky Way. Here’s the catch: there is also an equally likely chance that those civilizations are nowhere near as advanced as us. In fact, it’s quite possible that we may be among the first. It’s also quite possible that there may have been many civilizations that have already risen, hit their peak, and then died off, for one reason or another.
We don’t know. In fact, we may never know. We may be like those possible civilizations that rose, peaked, and fell without ever contacting another living world in the whole of their existence. Depressing, isn’t it? So here is my suggestion to you.
 Study science and technology, physics, math, anything that helps increase the possibilities of communication with anyone or anything Out There. Try to break the Rule: most civilizations might never contact another. Do something unique. Think outside the box; in fact, get rid of the box altogether and think in ways that have never been attempted. But stay smart and scientific. Don’t trade reality for fantasy and imagine that every light in the sky is an alien spacecraft visiting us. Instead, figure out a way to build spacecraft of our own to go Out There and find those aliens. It’s worth doing.


We remain aware of the mission We aim to collaborate, and help students through our programmes to inspire and integrate them, using innovative ways. We care for children and people We believe children are gifts of god and any service to them is service to god. We are committed to providing everyone and opportunity to learn, grow and help others grow. We treat everyone with respect We treat all with respect, dignity and honesty. We show respect by listening to and seeking to understand different points of views, being sensitive to cultural and religious diversity, and by working collaboratively with others to achieve common goals and a harmonious work culture. We collaborate to build partnerships We actively seek to partner with organizations with similar goals, individuals, and corporates to enhance the effectiveness of our programs and advance common interests. We honour the responsibilities entrusted to us We constantly seek opportunities and innovative ways to create value through the work that we do to further our mission.


Queensland police charge woman with murder after children aged one and two found dead in car at Logan
Queensland Police have charged a woman with murder following the investigation into the deaths of two toddlers who were found dead in a car.
The children, two girls, showed signs of exposure to extreme heat, Queensland police say.
Paramedics tried to revive the children, aged one and two, after being called to a home in Waterford West about 1.35pm on Saturday.
Police declared a crime scene around a black station wagon parked in the driveway at the front of the property on Logan Reserve Road.
A 27-year-old Waterford West woman, who is known to the girls, has been charged with two counts of murder and will appear at the Brisbane Magistrates Court on Monday November 25.


65. at-Talaq: The Divorce
1
O Prophet! When ye (men) put away women, put them away for their (legal) period and reckon the period, and keep your duty to Allah, your Lord. Expel them not from their houses nor let them go forth unless they commit open immorality. Such are the limits (imposed by) Allah; and whoso transgresseth Allah's limits, he verily wrongeth his soul. Thou knowest not: it may be that Allah will afterward bring some new thing to pass.
2
Then, when they have reached their term, take them back in kindness or part from them in kindness, and call to witness two just men among you, and keep your testimony upright for Allah. Whoso believeth in Allah and the Last Day is exhorted to act thus. And whosoever keepeth his duty to Allah, Allah will appoint a way out for him,
3
And will provide for him from (a quarter) whence he hath no expectation. And whosoever putteth his trust in Allah, He will suffice him. Lo! Allah bringeth His command to pass. Allah hath set a measure for all things.
4
And for such of your women as despair of menstruation, if ye doubt, their period (of waiting) shall be three months, along with those who have it not. And for those with child, their period shall be till they bring forth their burden. And whosoever keepeth his duty to Allah, He maketh his course easy for him.
5
That is the commandment of Allah which He revealeth unto you. And whoso keepeth his duty to Allah, He will remit from him his evil deeds and magnify reward for him.
6
Lodge them where ye dwell, according to your wealth, and harass them not so as to straiten life for them. And if they are with child, then spend for them till they bring forth their burden.  Allah asketh naught of any soul save that which He hath given it. Allah will vouchsafe, after hardship, ease.
8
And how many a community revolted against the ordinance of its Lord and His messengers, and We called it to a stern account and punished it with dire punishment,
9
So that it tasted the ill-effects of its conduct, and the consequence of its conduct was loss.
10
Allah hath prepared for them stern punishment; so keep your duty to Allah, O men of understanding! O ye who believe! Now Allah hath sent down unto you a reminder,
11
A messenger reciting unto you the revelations of Allah made plain, that He may bring forth those who believe and do good works from darkness unto light. And whosoever believeth in Allah and doeth right, He will bring him into Gardens underneath which rivers flow, therein to abide for ever. Allah hath made good provision for him.
12
Allah it is who hath created seven heavens, and of the earth the like thereof. The commandment cometh down among them slowly, that ye may know that Allah is Able to do all things, and that Allah surroundeth all things in knowledge.
-- Sura 65 --


Your captured image will appear here...
WebcamJS Test Page
Demonstrates simple 320x240 capture & display
Latest photo from server


Par kahte hai na, there is more to everything.
Branding | Web | AdminPanel
Branding | Web | AdminPanel
Branding | Web | AdminPanel
Branding | Web | AdminPanel
Branding | Web | AdminPanel
Branding | Web | AdminPanel


|
JNIPort for Dolphin Smalltalk |
|
|
Back to Goodies |
The Java Native Interface (JNI)JNI, the “Java Native Interface”, is the API by which programs written in C, or a similar language, can interact with a Java runtime. Dolphin's external interfacing feature is able to use the JNI API and the whole of JNIPort is built on it. The JNI specification is included in the J2SDK documentation; by all means read it (if you don't know it already) but be warned: JNI is one of the most unpleasant APIs I've ever worked with. To be fair, a lot of that is because Sun were in the difficult position of specifying a low-level interface to a garbage collected virtual machine without constraining the implementation of the VM or garbage collector. On the other hand, I don't doubt that much of the difficulty is because the JNI API was rushed and poorly thought-out. I have no intention of writing an introduction to JNI; if you are interested then you may like to look at the JNI trail in the Java tutorial. Sun have also put the JNI book online. The rest of this section assumes that you know both JNI and Dolphin's external interfacing (which may be an unrealistic expectation, I admit).
The package 'CU JNI' contains
plus the two vtable-like structures:
which, luckily, are close enough to the layout of a real COM or C++ object for Dolphin to be able to handle them without trouble.
By the way, don't confuse the
The package also contains an
The package also includes The idea of this package is to provide only a very thin layer around raw JNI. It is important (should you use this layer without the rest of JNIPort) that you realise that it does not manage the lifetime of references to Java objects automatically, you have to track references yourself and release them explicitly.
The package does go a little beyond the raw JNI specification. It provides a set of subclasses
of
The central objects at this level are the JNIEnv “pointers”.  This package exposes the methods as Smalltalk methods.
The way that JNI works requires the programmer to check for errors/exceptions after each
step, so the
For two simple (Ha!) examples of raw JNI programming using this package, see
|
Copyright © Chris Uppal, 2003-2005
Java, JNI (probably), JVM (possibly), and God knows what else, are trademarks of Sun Microsystems, Inc.


SCENES FROM A MALL A film review by Mark R. Leeper Copyright 1991 Mark R. Leeper
Capsule review: If you think it is funny to see adults argue in public, perhaps this comedy is for you. Then again, if you do think so, who knows what else you would like? Another Beverly Hills comedy that makes this Easterner wonder if he is missing the point. Rating: -1 (-4 to +4).
Somebody once told me they thought they could listen to and watch Woody Allen reading white pages out of the phone book and it would be funny.  Bette Midler can also be very funny. So the question is, how long can this couple play a loving and quarreling couple walking around a mall and still carry the film on their innate cuteness. Well, based on the results in Paul Mazursky's SCENES FROM A MALL, the two of them might be able to carry the premise for up to about ten minutes. After that, they definitely need an assist from a script and the script in SCENES FROM A MALL by Roger Simon and director Mazursky does little to help. At least it does little unless you think that everything connected with Beverly Hills is really cute. If your idea of a good joke is seeing a line of cars with each driver talking on a cellular phone, perhaps you will enjoy this film, but I would bet you will find far more on-target and funny in L.A. STORY.
On their sixteenth wedding anniversary, lovey-dovey couple Nick (played by Woody Allen) and Deborah (played by Bette Midler) go to a mall on an errand. There they get into a fight over fidelity and decide to break up. They reconcile and decide they still love each other. They fight again and break up. Then they get together again. Can you figure the plot from that point on? Yes, I thought you could.  That's what there is. It is a film with a beginning and a middle, but no end. It is just arbitrarily cut off at the end of a cycle. It would be one thing if these people were at least great conversationalists. But this is no MY DINNER WITH ANDRE. About all you learn from the conversation is that these are two very ordinary and superficial people. Do you really care where they got their roll-top desk and which of them is going to get it in the divorce settlement? I know I do not. You could easily save the admission price by going to your local mall and eavesdropping on the people there.
There are some things that Mazursky is more anxious to show us than others. We do get to see the names of a lot of stores at the mall, many of which--surprise! surprise!--are chains that you might find at your own local mall. How fortuitous for the financing of the film! Considerably less care is taken to show us what the characters are doing with their packages. At one point each has bought a complete change of clothes which they are wearing. No explanation is given for what happened to the clothes they had been wearing. I guess in Beverly Hills, everything you own is considered disposable.
If you genuinely find great humor in the awkward situation of seeing adults argue in public, this predominantly one-joke comedy might be for you. If not, it offers you surprisingly little considering the names involved. I give it a -1 on the -4 to +4 scale.
Mark R. Leeper att!mtgzy!leeper<EMAIL_ADDRESS>.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


--- layout: default ---
Sorry, but the page you were trying to view does not exist.
Redirect to home ?


August 2022 Status Update
Welcome! It’s the first Tuesday of every month, and that means the latest starbeam.one Status Update! Let’s begin here.
Program Notes
Astute readers will realize that I am posting this on a Thursday, and not a Tuesday. While I was able to record the latest Stand-up & Shine (and Shill) on Tuesday, I was not able to post it until this morning. There were a few issues with post-video production that took quite a bit of time and retakes. Turns out video processing is very intensive when you apply certain filters to it, and there were a lot of retakes involved in making sure the sensitive information I was providing during the demonstrations were adequately scrubbed.
This is what I get for running live demonstrations in the production environment! With real live sensitive data, at that.
Past that, there were also a few issues/bugs unveiled during recording the demonstrations. I took some time to get these addressed, deployed, and ready for the world to see.
With that, let’s move into the good stuff.
Announcing the Friends & Family Alpha… Twitter Edition™
Back in June I announced the Friends & Family alpha, and then immediately spent the next two weeks fixing bugs discovered during said announcement and its subsequent recording. It was a bit of a bummer, and I never got to announce it on Twitter, where I feel you have to really have your ducks in a row when you put something “out there.”
There was also the slight detail that I was accepting monetary value without an efficient way of viewing and managing it, if necessary. Yes, I can see everything using Sql Server, but that is a bit informal (and error-prone) for my tastes.
I needed to flesh out my already half-developed Administration Application to get it to a place where I could feel a little more comfortable accepting (and managing) funds. What if someone asked for a refund? I didn’t even have a policy in place, let alone the ability to quickly provide one.
So after fixing bugs, I spent more time on the Administration Application and getting core features in place to feel a little more in control of this baby that I have birthed (I am sure that parents will be quick to tell you that you are never in control, however!).
Let’s discuss some key features now in place with the latest alpha version.
Administration Application
As mentioned, starbeam.one now features an Administration Application that administrators (read: me :)) can use to view and administer certain aspects of the system. If a process fails, for instance, it can easily be restarted. User accounts can also be disabled, if needed (hopefully this will not be needed any time soon, of course!), and other such tasks.
But more importantly, it introduces workflow processes such as approval/rejection for features such as withdrawals and/or refunds. Speaking of which…
Refunds!
starbeam.one now features self-managed refunds for purchases made with PayPal and Stripe (Coinbase is on the way next). Refunds can be made with unspent credits within 30 days of purchase. Please read the refund policy for full details.
(Coinbase) Withdrawals!
In addition to making withdrawals via PayPal Payouts, starbeam.one now allows you to do the same via your Coinbase Retail account. That means not only one but two ways of receiving value from your starbeam.one account when you deem appropriate. This not only provides options for users of the system, but also redundancy in case one of the off ramps go down for any reason.
Note that restrictions are in place with withdrawals while the system is under test and confidence is gained with this functionality. Please see the withdrawals policy for the details.
Stand-up & Shine (& Shill)
So many new features! So much amaze! I am super happy with where things are now as opposed to June. The horse feels put in front of the cart now and I start talking about this project in earnest on Twitter (and more).
If you are interested in watching me talk for 40 minutes+ about these features while also showing them off, you should check out the latest version of Stand-up & Shine (& Shill) which can be seen below:
Thank you!
A quick shout out to all the support and appreciation that you all continue to show out there. starbeam.one’s YouTube Channel now features 15 subscribers. This which may not seem a lot, but it is a tremendous accomplishment to me as I didn’t think I was going to get even one. :) I very much appreciate all the support in any form it arrives.
Until next time, stay bright! ✨


Beep Boop Converter
Would you like to customize the output with your name?
Yes
No
Sort Order:
Forward
Reverse
You don't have to enter your name BUT..
Enter a number and receive a converted output back:
You'll be surprised with the outcome!
Submit
Reset


This package wraps Fortran code by F. D. Colavecchia and G. Gasaneo for computing the Appell's F1 hypergeometric function. Their program uses Fortran code by L. F. Shampine and H. A. Watts. Moreover, the hypergeometric function with complex arguments is computed with Fortran code by N. L. J. Michel and M. V. Stoitsov or with Fortran code by R. C. Forrey. See the function documentations for the references and please cite them accordingly.
| Version: | 0.0-4 |
| Depends: | R (≥ 2.14.0) |
| Published: | 2013-04-16 |
| Author: | Daniel Sabanes Bove with contributions by F. D. Colavecchia, R. C. Forrey, G. Gasaneo, N. L. J. Michel, L. F. Shampine, M. V. Stoitsov and H. A. Watts. |
| Maintainer: | Daniel Sabanes Bove <daniel.sabanesbove at ifspm.uzh.ch> |
| License: | GPL (≥ 3) |
| NeedsCompilation: | yes |
| Materials: | ChangeLog |
| In views: | NumericalMathematics |
| CRAN checks: | appell results |
| Reference manual: | appell.pdf |
| Package source: | appell_0.0-4.tar.gz |
| Windows binaries: | r-devel: appell_0.0-4.zip, r-release: appell_0.0-4.zip, r-oldrel: appell_0.0-4.zip |
| OS X binaries: | r-release: appell_0.0-4.tgz, r-oldrel: appell_0.0-4.tgz |
| Old sources: | appell archive |
Please use the canonical form https://CRAN.R-project.org/package=appell to link to this page.


--- layout: default nav: dependencies ---
ic-action-target
attribute, allowing for a distinct target for the ic-action
attribute.
ic-sse-src
attribute, allowing intercooler to utilize Server Sent Events .
ic-swap-style
attribute, making append/prepend explicit attribute-driven behaviors.
ic-poll
attribute now does not ignore dependencies.
ic-trigger-from
attribute, to allow specifying the element to listen to for the
event that triggers an intercooler request.
X-IC-Title
response header
localStorage
using
the ic-local-vars
attribute and X-IC-Set-Local-Vars
response
header.
autofocus
attribute in intercooler AJAX responses.
ic-last-request
parameter to avoid cache busting. Server-side cookies should be used
for more consistent refresh timing information.
ic-prompt
attribute now
stops intercooler from issuing an ajax request.
data-*
prefix on attributes via the
<meta name="intercoolerjs:use-data-prefix" content="true"/>
meta-tag.
beforeAjaxSend.ic
, which allows programmers to modify the setting hash passed
to $.ajax()
to do thinks like add headers, set content type, remove parameters, etc.
Intercooler
object.
ic-action
attribute, allowing
for pure declarative client-side operations in intercooler.
ic-select-from-response
now takes the inner HTML content of the given element, rather than
the entire element. This makes the API more natural to work with, but unfortuantely breaks backwards compatibility.
ic-indicator
class will now work on next sibling of element firing request
ic-patch-to
attribute was added to suppor the PATCH
action
Intercooler.defaultTransition()
and
Intercooler.defineTransition()
have been deprecated and now have no effect.
Intercooler.addURLHandler()
and Intercooler.setRemote()
have been deprecated
and now have no effect.
ic-add-class
and ic-remove-class
were added to make it easy to create CSS transition
based easements in your Intercooler application.
ic-global-include
allows you to include data with requests made by every element on a page.
ic-beforeTrigger
allows you execute logic before Intercooler fires a request (and potentially
cancel the trigger).
ic-pause-polling
allows you issue an element with an ic-poll
attribute in it that
is in a paused state.
X-IC-ResumePolling
response header allows you to restart polling for an element.
ic-post-errors-to
allows you specify a URL for intercooler to post client side errors to.
ic-prompt
allows you to prompt the user for input before a request, asking for input.
ic-remove-after
allows you to remove an element after a given time period.
ic-scroll-to-target
and ic-scroll-offset
allow you to scroll to the top of a target
if it is not visible in the viewport.
ic-transition-duration
allows you to tell intercooler to wait some amount of time for a CSS
transition to complete before a swap is done.
ic-target-id
, ic-trigger-id
and ic-trigger-name
parameters were all
added to intercooler requests, to make it easier to dynamically determine which partial to render in response
to a given url
X-IC-Trigger-Data
has been deprecated. The X-IC-Trigger
attribute can now be
either a plain string for the event name, or a JSON object that satisfies the jQuery
parseJSon()
requirements, where each property
is an event name to trigger, and the value of each property is an array of arguments to pass to that
event.
ic-select-from-response
attribute, allowing people to select sub-elements from a
server response to swap in.
ic-include
attribute to allow for JSON name/value pairs to be included in a
request.
ic-always-update
to true, so you have to opt out of content swapping now.
ic-remove-after
attribute, allowing people to remove an element after a given
interval of time cleanly.
ic-push-url
attribute. Renamed the X-IC-SetLocation
response header to X-IC-PushURL
to be consistent with the new attribute.
ic-current-url
parameter.
ic-trigger-delay
attribute to delay firing a request.
ic-replace-target
attribute, allowing full replacement of target elements
for situations like replacing a table row.
ic-target
attribute
via the closest
prefix.
ic-on-beforeSend
, ic-on-success
, ic-on-error
and
ic-on-complete
attributes.
script
element, so things are properly reevaluated.
LeadDyno.processElements()
in the Javascript APIX-HTTP-Method-Override
header up in intercooler requestsX-IC-Request
header up in intercooler requestsX-IC-Trigger
response header to trigger client
side event
handlers.
ic-confirm
attribute.
The big enhancement in this release (small code change, but big functionality boost!) is the X-IC-Trigger
response header, which finally solves a tricky problem I've been wrestling with: How do you communicate server side state
changes that have client-side UI ramifications that fall outside the usual Intercooler request-and-replace
partial view flow?
This new mechanism allows you to cleanly separate your server side and client-side logic even in cases where the simple content-swapping approach isn't enough.
A great example is if you want to hide a modal if and only if a form in the modal submits valid data to the
server. You can now easily fire an server.accountCreated
event (as an example) from the server side
and respond to that on the client side by hiding the modal. Clean, crisp and very little code!
You can download the latest intercooler.js
from the Downloads page.
Enjoy!


The algorithm is implemented in CreditCardValidator.java. It validates a list of hard-coded credit card numbers, or any number passed as command line arguments. For example, try CreditCardValidator.html?myNumber=4417-1234-5678-9113
Here and with the Java 5 Features Demo you see that the values of URL query parameters are passed to the
declared onLoad
-method.


--- layout: archive title: Zulip Chat Archive permalink: /stream/113489-new-members/topic/what.20is.20the.20type.20of.20fst.3F.html ---
Hi everyone! The tutorial https://leanprover.github.io/theorem_proving_in_lean/dependent_type_theory.html#function-abstraction-and-evaluation gives example of function fst and snd: "If we have p : nat × nat, then we have fst p : nat"
I tried to "guess" the type of fst so I made fst' (I finished the chapter so I could do an educated guess):
constant fst': Π {α: Type u} {β: Type v}, α × β → α
#check fst' -- ?M_1 × ?M_2 -> ?M_1
#check fst' (1, 2) -- nat
So I then tried to compare it with the fst function mentioned in the tutorial:
#check fst
But I got: unknown identifier 'fst'
My question is:
1) Did I define the type of fst' correctly?
2) What should I do to be able to use fst mentioned in the tutorial?
Thanks a lot.
It's called prod.fst
; presumably the tutorial had the prod
namespace open
The first mention of namespaces in TPiL is in section 2.7, but this question is about the sentence at the beginning of 2.3:
Conversely, if we have
p : nat × nat
, then we havefst p : nat
andsnd p : nat
.
Also, while the notations .1
and .2
are mentioned earlier (at the end of 2.1), the quote above is the first place where fst
and snd
are mentioned, and then fst
and snd
don't appear again in this chapter until the end of 2.8 (in the context of sigma
). Maybe the above should be changed to "then we have p.1 : nat
and p.2 : nat
"? @Jeremy Avigad
@agro1986 In case this wasn't obvious from what Mario said, the type you gave for fst'
is correct. You can check it against what Lean uses with #check @prod.fst
.
Thanks, Bryan. I will fix this.
(deleted)
@Mario Carneiro @Bryan Gin-ge Chen Wow thanks a lot!!!
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


????
Lorem ipsum dolor sit amet consectetur adipisicing elit. Pariatur ab nulla atque consectetur expedita illo quos neque rem corrupti nisi?
Procedure
Life Of PY will be an event comprising of a team of 2 people, and the resigstrations will be open for all category with no prequistes from the participants. It will contain a total of 3-5 proble statements from different genre of Python which will be available to all the participants from start of the event. Anyone can start solving in any order and submit multiple solutions.
Scoring Pattern
Each problem statement will have its own requirement for scoring and submisiions will be judged on the same basis. The most optimized submission will be given highest marks followed by subsequent optimized submissions. The final scoreboard will be prepared from collective scores in problems solved by the team. From the final scoreboard, top 10 teams will be eligible for he prizes.
Benifit to Qualified Teams
The top 10 teams eligible for prizes will be awarded with goodies from Neodristi partner (i.e. Devfolio) and will get direct entry to finale main event i.e. "Tame the Python" in OJASS'20
What is “Tame the Python”?
Tame the Python is one of our 5 main events under NeoDrishti which focuses on Python development tools and libraries. The event structure is as follows:
Prelims: Prelims will be conducted on spot during OJASS’20 this year in the month of February.
(Expected Dates between 28th Feb and 1st March). This round will contain MCQ problems based on basics of python and 10 teams from this prelims will be selected for Finale.
Finale: Finale round will combine participants from the on-spot prelims and the Hackathon as mentioned earlier and the teams selected will be participating in the Finale which is divided into two sub-sections, namely
1) Basic CLI Python projects on libraries which will be published on our official Facebook page before the event (At least 3 weeks before).
2) Teams will then participate in a competitive coding based event named as Code Golf which aims to minimize the number of letters used to solve problem using python.
Final scores from both sub-sections will be calculated and winners will be announced on the spot.
Our Sponsors
Frequently asked questions (FAQs)
Hackathon is open for all with no pre-requisites or eligibility criteria.
That totally depends on you, you can use any library you wish to use.
Event is completely online and you can participate in it from anywhere in world.
To participate, click on "Apply with Devfolio" button. You will then be able to create your project once the hackathon starts. To be eligible for the judging process you'll have to submit the project before the hackathon ends.
No, our events are always awesome and free of charge. All we ask for is your passion and dedication to code this world for better.
Zero. Nil. Nothing. Participation in LifeOfPy is completely free.
Ask your questions in Contact Us section down there or reach out to us at nd.ojass@nitjsr.ac.in


File Name: Beach Sunset
Uploaded by: Sn۞Wflake™
Date: 21.08.2014
Category: Beach
Image Size: 1920x1200 px
File Size: 371.41 Kb
Short Link
HTML
BBCode
Image Size: 1600 x 1000 px
Image Size: 1920 x 1200 px
Image Size: 1920 x 1080 px
Image Size: 1680 x 1050 px
Image Size: 2560 x 1440 px


You Sick Brah?
IN THE PAST 24 HOURS, have you had any of the following symptoms?
- Fever (100.0°F, 38.7°C )
- Cough (not due to Allergies)
- Sore throat
- Shortness of Breath
- New loss of taste or smell
- A Sense of Impending Doom
Have you been tested for the virus that causes COVID-19 with a positive orpending result in the last 14 days?
Have you had
CLOSE PERSONAL CONTACT, with anyone who has been diagnosed with COVID-19 in the past 14 days?
- Withing 6 feet for a prolonged period of time (15 minutes or more)
- In direct contact with infection secretions (been coughed/sneezed upon, etc.)
Are you arriving/returning from out of the local area in the last 14 days?
Is the place you visited going through a pandemic?
Did you travel via public transportation (air, train, bus)?
Did you have intermediate stops in a region going through a local pandemic?


### Optimizing Julia code is often done at the expense of transparency ```julia using Random, LinearAlgebra, BenchmarkTools function test(A, B, C) C = C - A * B return C end A = rand(1024, 256); B = rand(256, 1024); C = rand(1024, 1024) @btime test(A, B, C); #C, A and B are matrices. ``` ``` 5.265 ms (4 allocations: 16.00 MiB) ``` -- ```julia function test_opt(A, B, C) BLAS.gemm!('N','N', -1., A, B, 1., C) return C end @btime test_opt(A, B, C) # avoids taking two unnecessary copies of the matrix C. ``` ``` 2.441 ms (0 allocations: 0 bytes) ``` -- ```julia C = rand(1024, 1024) all(test(A, B, C) .== test_opt(A, B, C)) ``` ``` true ``` --- ### Derivative computation with FFT ```julia using FFTW xmin, xmax, nx = 0, 4π, 1024 ymin, ymax, ny = 0, 4π, 1024 x = range(xmin, stop=xmax, length=nx+1)[1:end-1] y = range(ymin, stop=ymax, length=ny+1)[1:end-1] ky = 2π ./ (ymax-ymin) .* [0:ny÷2-1;ny÷2-ny:-1] exky = exp.( 1im .* ky' .* x) function df_dy( f, exky ) ifft(exky .* fft(f, 2), 2) end f = sin.(x) .* cos.(y') # f is a 2d array created by broadcasting @btime df_dy(f, exky) ``` ``` 106.520 ms (127 allocations: 64.01 MiB) ``` --- ### Memory alignement, and inplace computation. ```julia f = zeros(ComplexF64, (nx,ny)) fᵗ = zeros(ComplexF64, reverse(size(f))) f̂ᵗ = zeros(ComplexF64, reverse(size(f))) f .= sin.(x) .* cos.(y') fft_plan = plan_fft(fᵗ, 1, flags=FFTW.PATIENT) function df_dy!( f, fᵗ, f̂ᵗ, exky ) transpose!(fᵗ,f) mul!(f̂ᵗ, fft_plan, fᵗ) f̂ᵗ .= f̂ᵗ .* exky ldiv!(fᵗ, fft_plan, f̂ᵗ) transpose!(f, fᵗ) end @btime df_dy!(f, fᵗ, f̂ᵗ, exky ) ``` ``` 36.190 ms (3 allocations: 176 bytes) ``` --- # Why use Julia language! * **You develop in the same language in which you optimize.** * Packaging system is very efficient (3173 registered packages) * PyPi (198,360 projects) R (14993 packages) * It is very easy to create a package (easier than R and Python) * It is very easy to use GPU device. * Nice interface for Linear Algebra and Differential Equations * Easy access to BLAS and LAPACK * Julia talks to all major Languages - mostly without overhead! --- # What's bad * It is still hard to build shared library or executable from Julia code. * Compilation times can be unbearable. * Plotting takes time (20 seconds for the first plot) * OpenMP is better than the Julia multithreading library but it is progressing. * There is a MPI and PETSc package but they are not very active. * For parallelization, The Julia community seems to prefer the ditributed processing approach. * Does not work well with vectorized code, you need to do a lot of inplace computation to avoid memory allocations and use explicit views to avoid copy. * Julia website proclaims that it is faster than Fortran but this is not true. [What's Bad About Julia by Jeff Bezanson](https://www.youtube.com/watch?v=TPuJsgyu87U) --- ## So when should i use Julia? * Now! If you need performance and plan to write your own libraries. * In ~1-2 Years if you want a smooth deploy. * In ~3-5 Years if you want a 100% smooth experience. ## Julia Munich Meetup Every two months, poll for the next meeting that will take place at Garching Campus : https://doodle.com/poll/z3ft2dytnaebyhh7. ## Python-Julia benchmarks by Thierry Dumont https://github.com/Thierry-Dumont/BenchmarksPythonJuliaAndCo/wiki --- # Julia is a language made for Science. [Some State of the Art Packages](http://www.stochasticlifestyle.com/some-state-of-the-art-packages-in-julia-v1-0) * JuliaDiffEq – Differential equation solving and analysis. * JuliaDiff – Differentiation tools. * JuliaGeometry – Computational Geometry. * JuliaGraphs – Graph Theory and Implementation. * JuliaIntervals - Rigorous numerics with interval arithmetic & applications. * JuliaMath – Mathematics made easy in Julia. * JuliaOpt – Optimization. * JuliaPolyhedra – Polyhedral computation. * JuliaSparse – Sparse matrix solvers. * JuliaStats – Statistics and Machine Learning. * JuliaPlots - powerful convenience for visualization. * JuliaGPU - GPU Computing for Julia. * FluxML - The Elegant Machine Learning Stack. *This page was generated using [Literate.jl](https://github.com/fredrikekre/Literate.jl).*


roave-backward-compatibility-check
A tool that can be used to verify backward compatibility breaks between two versions of a PHP library.
More information: home page
- Check for breaking changes since the last tag:
roave-backward-compatibility-check
- Check for breaking changes since a specific tag:
roave-backward-compatibility-check --from=git_reference
- Check for breaking changes between the last tag and a specific reference:
roave-backward-compatibility-check --to=git_reference
- Check for breaking changes and output to Markdown:
roave-backward-compatibility-check --format=markdown > results.md


{% extends "layout.html" %} {% block body %} {% if not pattern %}
| Key | View |
|---|---|
| {{key}} | View |
Key queries should only be used in production environments with extreme care. It may ruin performance when it is executed against large databases.
{% endif %} {% endblock %}


Ukrainian soldier killed amid 15 enemy attacks in Donbas on Nov 14
The enemy opened fire from 82mm mortars, cannons installed on infantry fighting vehicles, grenade launchers, heavy machine guns, and rifles.
Russia's hybrid military forces on November 14 mounted 15 attacks on Ukrainian army positions in Donbas, eastern Ukraine, with one Ukrainian soldier reported as killed in action.
"The armed forces of the Russian Federation and its mercenaries violated the ceasefire 15 times on November 14. One Ukrainian soldier was killed in enemy shelling," the press center of the Joint Forces Operation Headquarters said on Facebook in a morning update on November 15.
The enemy opened fire from 82mm mortars, cannons installed on infantry fighting vehicles, grenade launchers of various types, heavy machine guns, and small arms.
Under attack were Ukrainian positions near the town of Krasnohorivka, and the villages of Kamianka, Pisky, Novomykhailivka, Shyrokyne, Hnutove, Zholobok, Novoluhanske, Luhanske, Mayorsk, Novotoshkivske, and Orikhove.
"Since midnight, Russia-led forces have opened fire on Ukrainian positions once near Novoluhanske, using hand-held anti-tank grenade launchers and rifles," the report said.


Unblock Me
问题描述 :
Unblock Me is a simple and addictive puzzle game on iPhone/iPod Touch. The goal is to get the red block out of the board by sliding the other blocks out of the way.
You can only move the block if it has a free space to move. In one step, you can move only one block, and you can move multiple units. To clear the puzzle, you have to move the red block out of the board. The red block can only move in horizontal direction. The vertical blocks can move in vertical direction only. The horizontal blocks can move in horizontal direction only.
Now try to crack it. The board is 6*6. There are two kinds of vertical blocks (1*2, 1*3), and two kinds of horizontal blocks (2*1, 3*1). The exit is always at the right of the grid (5, 2).
You can only move the block if it has a free space to move. In one step, you can move only one block, and you can move multiple units. To clear the puzzle, you have to move the red block out of the board. The red block can only move in horizontal direction. The vertical blocks can move in vertical direction only. The horizontal blocks can move in horizontal direction only.
Now try to crack it. The board is 6*6. There are two kinds of vertical blocks (1*2, 1*3), and two kinds of horizontal blocks (2*1, 3*1). The exit is always at the right of the grid (5, 2).
输入:
There are several cases in the input data.
For each case:
The first line contains a number N which indicates how many blocks are on the board, then N lines follows. Each line contains five numbers. The first number is the index of this block, which increase from 0 to N-1. The next two numbers is the coordinate of the left upper corner. The last two numbers is the coordinate of the right down corner.
The last line contains one number which is the red block’s index.
For each case:
The first line contains a number N which indicates how many blocks are on the board, then N lines follows. Each line contains five numbers. The first number is the index of this block, which increase from 0 to N-1. The next two numbers is the coordinate of the left upper corner. The last two numbers is the coordinate of the right down corner.
The last line contains one number which is the red block’s index.
输出:
There are several cases in the input data.
For each case:
The first line contains a number N which indicates how many blocks are on the board, then N lines follows. Each line contains five numbers. The first number is the index of this block, which increase from 0 to N-1. The next two numbers is the coordinate of the left upper corner. The last two numbers is the coordinate of the right down corner.
The last line contains one number which is the red block’s index.
For each case:
The first line contains a number N which indicates how many blocks are on the board, then N lines follows. Each line contains five numbers. The first number is the index of this block, which increase from 0 to N-1. The next two numbers is the coordinate of the left upper corner. The last two numbers is the coordinate of the right down corner.
The last line contains one number which is the red block’s index.
样例输入:
12 0 0 1 0 2 1 1 0 1 1 2 2 0 2 1 3 3 0 5 0 4 1 2 2 2 5 3 1 3 2 6 4 1 4 2 7 5 1 5 3 8 0 3 1 3 9 2 3 3 3 10 4 3 4 4 11 0 4 0 5 4
样例输出:
16HintSee the image below to get more details.
http://acm.hdu.edu.cn/showproblem.php?pid=3900
状压BFS。。。
#include<cstdio> #include<cstring> #include<iostream> using namespace std; #define ll long long struct data { int t,l,c; ///t---type 0:heng 1:shu l:length }B[3545]; ///c:weizhi int n,r; ///red block #include<map> #include<queue> #include<set> map<ll,bool > vis; ll s; inline bool check(ll s,int x) /// Xth block { int tx=(s&(7ll<<(x*3)))>>(x*3); for(int i=0;i<n;i++) { if(i==x) continue; int ti=(s&(7ll<<(i*3)))>>(i*3); if(B[x].t==B[i].t) { if(B[x].c!=B[i].c) continue; if(tx+B[x].l<=ti||ti+B[i].l<=tx) continue; return 0; } else { if(tx+B[x].l>B[i].c&&B[i].c>=tx&& ti<=B[x].c&&B[x].c<B[i].l+ti) { return 0; } } } return 1; } inline bool done(ll s) { for(int i=0;i<n;i++) { if(B[i].t==1) continue; int tt= ((s&(7ll<<(3*r)))>>(r*3)); if(B[i].c<tt+B[r].l) continue; int l=((s&(7ll<<(3*i)))>>(i*3)) , r=l+B[i].l; if(r<=2||l>2) continue; return 0; } return 1; } inline void cover(ll& s,int x,int p) { s&=~(7ll<<(x*3)); s|=(ll)p<<(x*3); } #define pii pair<ll,int> #define mp make_pair int bfs(ll s) { if(done(s)) return 1; queue< pii > q; q.push(mp(s,0)); vis.clear(); vis[s]=1; while(!q.empty()) { pii tt=q.front(); q.pop(); ll u=tt.first; int d=tt.second+1; for(int i=0;i<n;i++) { int p=(u&(7ll<<(i*3)))>>(i*3); for(int j=1;j<=p;j++) { ll v=u; cover(v,i,p-j); if(!check(v,i)) break; if(done(v)) return d+1; if(vis[v]) continue; vis[v]=1; q.push(mp(v,d)); } for(int j=1;p+j+B[i].l<=6;j++) { ll v=u; cover(v,i,p+j); if(!check(v,i)) break; if(done(v)) return d+1; if(vis[v]) continue; vis[v]=1; q.push(mp(v,d)); } } } return -1; } int main() { while(cin>>n&&n) { ll s=0; // cout<<s<<endl; for(int i=0;i<n;i++) { int t,lx,ly,rx,ry; cin>>t>>lx>>ly>>rx>>ry; if(lx==rx) { B[i].t=0; B[i].l=ry-ly+1; B[i].c=lx; s|=((ll)ly<<(3*i)); } else { B[i].t=1; B[i].l=rx-lx+1; B[i].c=ly; s|=((ll)lx<<(3*i)); } // cout<<"done:"<<done(s)<<endl; } cin>>r; // print(s); cout<<bfs(s)<<endl; } }
版权声明：本文为博主原创文章，未经博主允许不得转载。
参考：http://blog.csdn.net/oilover/article/details/20697463
(adsbygoogle = window.adsbygoogle || []).push({});
今天上映
今天上映
今天上映
今天上映
今天上映
今天上映
今天上映
今天上映
今天上映
今天上映
今天上映
赞！！~~大赞！！~
分析的很专业！
第一句可以忽略不计了吧。从第二句开始分析，说明这个花色下的所有牌都会在其它里面出现，那么还剩下♠和♦。第三句，可以排除2和7，因为在两种花色里有。现在是第四句，因为♠还剩下多个，只有是♦B才能知道答案。
第一题还是比较考验智商~
对于输出格式不用控制？？还是直接使用cout输出。？？
刚开始学习，为啥会报错了，你试过了吗
其实国内大部分公司对算法都不够重视。特别是中小型公司老板根本都不懂技术，也不懂什么是算法，从而也不要求程序员懂什么算法，做程序从来不考虑性能问题，只要页面能显示出来就是好程序，这是国内的现状，很无奈。
2的64次方是多少？ 这到底是在考什么啊
学习了。找到这题
博主的C++功底真是好
great work！
辛苦了，顶
这一题的代码这样提交时错误的~少考虑了很多情况
能不能说下这个是用的什么算法策略？