Copyright
2015, 2015 IBM
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0. Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
The Java code has the following Open Source dependencies:
Maven Build Values
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-csv</artifactId>
<version>1.1</version>
</dependency>
<dependency>
<groupId>org.jsoup</groupId>
<artifactId>jsoup</artifactId>
<version>1.8.2</version>
</dependency>
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.3.1</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>5.0.0.CR1</version>
</dependency>
</dependencies>
The IBM Data Merge Utility is an open source general purpose Java utility, exposed as an HTTP service, that uses Templates with your data source to create one or more merge output files. The merge process is driven by a set of directives associated with a template. The two types of directives are Replace and Insert and they drive the replacement of key values in a template, and the insertion of sub-templates. You can download source from GitHub here: https://github.com/FlatBallFlyer/IBM-Data-Merge-Utility
Need Content
Need Content
Need Content
Need Content
Need Content
Need Content
Need Content


{% extends "base.html" %} {% load fmt %} {% block title %}Delete {{ current_user }} ‹ User Manager ‹ YDNS{% endblock %} {% block content %}
You are about to delete user account #{{ current_user.id }}.
If you continue, all related hosts and domains are being deleted.
Do you really want to proceed?


GD - Sketch
Search
Browse
Add Your Company
A Game Developer tool for finding AAA opportunities
We provide services for developers to find the best companies within the game industry and learn about them as you go
Explore Game Teams
Add existing team


--- published: false layout: post title: "Yay this is a significant title" subtitle: "This is the subbiest title you've ever subtitled" date: 2015-01-01 09:11:03 categories: yay something asdf ---
By this time, without any solicitation, they were at the horse's head and were beginning to turn him around. The danger was imminent, but Brown found his voice again and saved himself. He said--
"But ladies, you are overlooking something which makes the plan impracticable.
"Dear, dear, what can we do?" said Mrs. Glossop; "it is the most mixed-up thing that ever was. The fox and the goose and the corn and things--Oh, dear, they are nothing to it."
They sat wearily down once more, to further torture their tormented heads for a plan that would work. Presently Mary offered a plan; it was her first effort. She said:
This plan was discussed and accepted; it seemed the best that could be done, in the circumstances, and the Old People must be getting discouraged by this time.
Brown felt relieved, and was deeply thankful. Let him once get to the main road and he would find a way to escape.
They sat wearily down once more, to further torture their tormented heads for a plan that would work. Presently Mary offered a plan; it was her first effort. She said:
This plan was discussed and accepted; it seemed the best that could be done, in the circumstances, and the Old People must be getting discouraged by this time.


00 - Hiking at Panther Mountain
01 - North Carolina
02 - Tennessee
03 - Kansas City and St Louis
04 - Monument Rock
05 - Colorado - Garden of Gods
06 - Colorado - Pikes Peak
07 - Colorado - Boulder and Caves
08 - New Mexico
09 - California
10 - Austin
11 - New Orleans


Press PgDown to display a list of fragments. The current fragment is highlighted.
You can prevent fragments from fading out by applying additional styles.
You can use highlights in source code to point things out.
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}


Next steps
1. Log into your Jenkins instance.
2. Make sure the Jenkins Artifactory Plugin is installed.
3. Make sure the go client is included in the Jenkins agent's PATH.
4. Configure your JFrog Platform details in Manage Jenkins | Configure System.
5. Replace the in the Jenkinsfile template JFROG_INSTANCE with the ID of the JFrog Platform instance you configured.
6. Push the Jenkinsfile to the root of your git project.
7. Create a Pipelines Jenkins job which uses the Jenkinsfile.
Additional information
The CI templates are hosted in the github.com/jfrog/jfrog-ci-templates repository.
More Jenkins pipeline examples are available here.
Read more about the Jenkins Artifactory Plugin used by the templates here.


×
Home Page
Profile
Customer Profile
Add
Update
Record Order
Individual
Corporate
Status Order
Corporate Data
Payment Receipt
Reports
Logout
☰ Menu
REPORTS
Monthly Sales Report
Location-based Report
Gender-based Report


Service Is Your Product, Too
Service Is Your Product, Too
As product people, we have a general disposition to put the product ahead of everything else—even, sometimes damagingly, the end-user.
But what happens when your product becomes commoditized? How do you differentiate in a world where who has the most or best features really doesn’t matter anymore?
That’s something I’ve seen many scaling product companies struggling with as I mature in my product management career, and it’s becoming more obvious that there’s a key differentiator that all-too-few product companies really appreciate.
Service.
Shaping Things Rather Than Helping People
In his 2005 missive on the future titled Shaping Things, Bruce Sterling writes about a future in which 3D printing effectively trivializes the act of producing physical products.
As it becomes trivial to manufacture an infinite number of different objects from an infinite number of blueprints which themselves are collaborated on by a near-infinite number of designers, the value of an object itself is lost.
Ultimately, Sterling’s thesis statement asserts that as this shift in value occurs, the way we perceive value, and how all of commerce, economics, and culture function will change as a result.
It’s a bit heady, but as I was reading it, I couldn’t help but note the parallel between that world view and my own when it comes to software products.
Ctrl-C, Ctrl-V, Buy Now
The same is increasingly true of software products. API platforms, SDKs, all manner of libraries from gems to packages, and the collective intelligence of communities like Stack Overflow make it increasingly trivial to build moderately successful software products.
When combined with even a ham-fisted approach to the science of design and iteration, even moderately successful products can be made wildly successful (albeit in the absence of ego-led development).
The dev teams today are solving scale challenges that their forebearers couldn’t have imagined, to be sure, but when it comes to straight up “app” writing, putting together a software product that solves a problem is trending towards being as trivial as printing a 3D model with a 3D printer.
So in a world where everyone can develop the same features in about the same time, and software is a commodity, what is left as a primary differentiator for an incumbent or entrant to distinguish itself?
Your Service Offering Belongs On The Box
Service, of course. And I don’t just mean support and refunds, but true customer success: helping your customers be successful when using your product to ultimately drive more business.
While we can automate increasing amounts of reality and problem-solving with advances in machine learning and networked software, good service remains an elusive and truly hard-to-replicate competitive differentiator for many a company.
Amazon and Zappos and Union Street Hospitality Group are, assuredly, three really good examples of this.
But you can see this approach in many different places, in companies large and small; in the many organizations that prioritize and package Customer Success alongside the Boxed Product®.
I get why many tech start-ups shy away from this as they scale. Scaling CS is very difficult; human resources are too often the only major cost centre for a software company, and with no other tweakable levers to keep the bottom line black, cutting back on people and divesting in people-centric operations seems an easy salve to the hard pain of scaling.
Alas, underinvesting in service has left many scaling software start-ups reeling as their businesses fail not only to generate customer referrals—a priceless commodity in an age when cost of acquisition rates for customers are soaring for everyone—but also to position themselves strategically and defensibly in a world where a disruptor can go from non-existent to market-winning faster than ever before.
That’s why Customer Success is such a critical differentiator. Particularly for B2B, great CS is both your viral marketing referral generator and your competitive differentiator.
Think about it: it’s really hard to build a great team, and it’s harder still to equip and organize that team towards success. That’s preciesely why that service, when achieved, should be part of the product offering and should be as much a consideration of the product team as the features that dot the app we and our teams so slavishly put on the App Store day after day.
Indeed, I believe (and the industry seems to be reaffirming) that only those product companies that can pair the robotic and increasingly-automated production of their wares with service that adds the humanity (and truly differentiator value) back into the mix will be truly successful in the long run.
That’s why it’s encumbent on us as product managers to view CS with the same passion, obsession, and excellence that we view our builds, bullet points, and branding.


Input file: cryspy.in
¶
Contents
File format¶
CrySPY uses the ConfigParser module to read input file, cryspy.in
.
cryspy.in
consists of sections, led by a [section]
header and followed by name = value
or name : value
entries.
Section names and values are case sensitive, but names are not.
Lines beginning with #
or ;
are ignored and may be used to provide comments.
Accepted Boolean values are 1
, yes
, true
, and on
, which cause this method to return True
, and 0
, no
, false
, and off
, which cause it to return False. These string values for Boolean are checked in a case-insensitive manner.
Some values are given in a space-separated manner.
See also
Attention
Example¶
cryspy.in
for YCo5 by random search:
[basic]
algo = RS
calc_code = VASP
tot_struc = 10
natot = 6
atype = Y Co
nat = 1 5
nstage = 4
njob = 5
jobcmd = qsub
jobfile = job_cryspy
[lattice]
minlen = 4
maxlen = 8
dangle = 20
mindist_1 = 2.0 1.8
mindist_2 = 1.8 1.5
[VASP]
kppvol = 40 100 100 100
[basic] section¶
| Name | Value | Default value | Description |
|---|---|---|---|
algo |
RS , BO , LAQA |
Algorithm | |
calc_code |
VASP , QE , soiap , LAMMPS |
Caluculation code for structure optimization | |
tot_struc |
integer | Total number of structures | |
natot |
integer | Total number of atoms in a unit cell | |
atype |
atomic symbol [atomic symbol ...] | Atom type | |
nat |
integer [integer ...] | Number of atoms in atom type1 [type2 ...] | |
nstage |
integer | Number of calculation stages | |
njob |
integer | Number simultaneously submitted jobs | |
jobcmd |
Specify a command to submit jobs, such as qsub | ||
jobfile |
Specify a jobfile to submit jobs for VASP, QE, and so on |
algo
¶
Available algorithms for crystal structure prediction are:
RS
: Random SearchBO
: Bayesian OptimizationLAQA
: Look Ahead based on Quadratic Approximation
In using LAQA, automatically fs_step_flag
= True
in [option] section.
calc_code
¶
CrySPY is interfaced with:
VASP
: VASP (https://www.vasp.at)QE
: Quantum Espresso (http://www.quantum-espresso.org)soiap
: soiap (https://github.com/nbsato/soiap)LAMMPS
: LAMMPS (http://lammps.sandia.gov)
[lattice] section¶
| Name | Value | Default value | Description |
|---|---|---|---|
minlen |
float | Minimum length of lattce vector | |
maxlen |
float | Maximum length of lattce vector | |
dangle |
float | Delta angle for alpha, beta, and gamma in degree unit | |
mindist_? |
float [float ...] | Constraint on minimum interatomic distance |
mindist
¶
A mindist matrix consists on mindist_1
, mindist_2
... . For example, in the case of YCo5 (atype = [‘Y’, ‘Co’]),
suppose taht mindist_1
is [2.0, 1,8] and mindist_2
is [1.8, 1.5].
The mindist matrix is
This means that minimum interatomic distances of Y-Y, Y-Co, and Co-Co are 2.0, 1.8, and 1.5, respectively. A mindist matrix should be a symmetric matrix.
Attention
mindist matrix: symmetric matrix
[VASP] section¶
| Name | Value | Default value | Description |
|---|---|---|---|
kppvol |
integer [integer ...] | Grid density per Angstrom-3 of reciprocal cell in each stage | |
force_gamma |
boolean | False |
If True, force gammma-centered mesh |
[QE] section¶
| Name | Value | Default value | Description |
|---|---|---|---|
kppvol |
integer [integer ...] | Grid density per Angstrom-3 of reciprocal cell in each stage | |
qe_infile |
Specify your QE input file name | ||
qe_outfile |
Specify your QE output file name |
[soiap] section¶
| Name | Value | Default value | Description |
|---|---|---|---|
soiap_infile |
Specify your soiap input file name | ||
soiap_outfile |
Specify your soiap output file name | ||
soiap_cif |
Specify your CIF-formatted soiap initial structure file name |
[LAMMPS] section¶
| Name | Value | Default value | Description |
|---|---|---|---|
lammps_infile |
Specify your LAMMPS input file name | ||
lammps_potential |
None |
Specify your LAMMPS potential, if any | |
lammps_outfile |
Specify your LAMMPS output file name | ||
lammps_data |
Specify your LAMMPS data file name |
[BO] section¶
| Name | Value | Default value | Description |
|---|---|---|---|
interval |
integer | Number of structures to calculate between learning data | |
score |
TS , EI , PI |
Acquisition function | |
num_rand_basis |
integer | 0 | If 0: Gaussian process, else: number of basis function |
cdev |
float | 0.001 | Cutoff of deviation for standardization |
dscrpt |
FP |
Descriptor for structure | |
fp_rmin |
float | 0.5 | Minimum cutoff of r in fingerprint |
fp_rmax |
float | 5.0 | Maximum cutoff of r in fingerprint |
fp_npoints |
integer | 50 | Number of discretized r points for each pair in fingerprint |
fp_sigma |
float | 0.2 | Sigma parameter in Gaussian smearing function in Angstrom unit |
[LAQA] section¶
| Name | Value | Default value | Description |
|---|---|---|---|
nselect |
integer | Number of structures to select at once | |
weight_laqa |
float | 1.0 | weight of bias |
weight_laqa
¶
In LAQA, the score is evaluated by the following equation:
where is weight_laqa
, weight of bias.
[option] section¶
| Name | Value | Default value | Description |
|---|---|---|---|
maxcnt |
integer | 200 | Maximum number of trials to determine atom positions |
stop_chkpt |
integer | 0 | Program stops at a specified check point |
symtoleI |
float | 0.001 | Tolerance for symmetry finding for Initial structures |
symtoleR |
float | 0.1 | Tolerance for symmetry finding for Relaxed structures |
spgnum |
all , space group number |
all |
Constraint on space group |
load_struc_flag |
boolean | False |
If True, load initial structures from ./data/pkl_data/init_struc_data.pkl |
stop_next_struc |
boolean | False |
If True, not submit next structures, but submit next stage and collect results |
energy_step_flag |
boolean | False |
If True, save energy_step_data in ./data/pkl_data/energy_step_data.pkl |
struc_step_flag |
boolean | False |
If True, save struc_step_data in ./data/pkl_data/struc_step_data.pkl |
fs_step_flag |
boolean | False |
If True, save fs_step_data (force and stress) in ./data/pkl_data/fs_step_data.pkl |


Synergy 2.9 release
-
Greg Hurrell
Announcement here:
http://wincent.com/a/news/archives/2006/06/synergy_29_avai.php
-
heavyboots
Big thanks to John Burgess & Wincent for the "Load artwork from Synergy" script included on the 2.9 disk image! Really cool, but I wanted it to do the entire album for each selected song, so I hacked some changes into it.
In hopes it may help others, anyone wants to fiddle with the results can download it below:
Load Artwork for Entire Album from Synergy
I saved it as an applet (editable) so that it can be hotkey triggered to launch from MaxMenus, btw. If you want to view the script contents, drag and drop it on Script Editor in the Dock. Finally! A relatively painless way to add all the album covers I've been missing over the years...
Details: Basically, I limited the selection to be one item exactly now and then inserted a bit of code that says to "set fullAlbum to every track whose (album = theAlbum) and (arist = theArtist)". Then I set the repeat loop to run on every item of fullAlbum instead of selection.
Caveats: I overrode the artwork check--I think the script will now always replace item 1 of artwork with the Synergy results. I've tested this on my machine for a couple hours with no problems so far, and done about 20 albums with no issues, but there are no guarantees, YMMV, etc etc etc.
Many thanks again to John for this script and I hope this helps others.
-
Greg Hurrell
Great to see the contribution, heavyboots!
Reply
This topic is now closed.


Oracle Labs Switzerland
October 2017
The following is intended to provide some insight into a line of research in Oracle Labs. It is intended for information purposes only, and may not be incorporated into any contract.
It is not a commitment to deliver any material, code, or functionality, and should not be relied in making purchasing decisions. Oracle reserves the right to alter its development plans and practices at any time, and the development, release, and timing of any features or functionality described in connection with any Oracle product or service remains at the sole discretion of Oracle.
Any views expressed in this presentation are my own and do not necessarily reflect the views of Oracle.
Should a message-based programming model have backpressure as a core primitive?
Syntax
terms ::=
...
spawn(t)
t ! t
t.onEvent(t)
open[T]
types ::=
...
Events[T]
Channel[T]
Semantics
P = { R }
program
Semantics
P = { R }
Semantics
P = { R }
R = (t, { C })
program
reactor
Semantics
P = { R }
R = (t, { C })
Semantics
P = { R }
R = (t, { C })
C = (c, e, x*, F)
program
reactor
connector
Semantics
P = { R }
R = (t, { C })
C = (c, e, x*, F)
Semantics
P = { R }
R = (t, { C })
C = (c, e, x*, F)
F = { f }
program
reactor
connector
callbacks
Semantics
P = { R }
R = (t, { C })
C = (c, e, x*, F)
F = { f }
How to encode a function that returns a backpressure channel?
def backpressure[T]: BackpressureChannel[T]
Encode backpressure as a composition of several simpler protocols.
type Req[T, S] = (T, Channel[S])
type Req[T, S] = (T, Channel[S])
type Server[T, S] = Channel[Req[T, S]]
type Req[T, S] = (T, Channel[S])
type Server[T, S] = Channel[Req[T, S]]
def server(f: T => S): Server[T, S] = {
}
type Req[T, S] = (T, Channel[S])
type Server[T, S] = Channel[Req[T, S]]
def server(f: T => S): Server[T, S] = {
val c = open[Req[T, S]]
}
type Req[T, S] = (T, Channel[S])
type Server[T, S] = Channel[Req[T, S]]
def server(f: T => S): Server[T, S] = {
val c = open[Req[T, S]]
c.events onEvent {
case (x, ch) => ch ! f(x)
}
}
type Req[T, S] = (T, Channel[S])
type Server[T, S] = Channel[Req[T, S]]
def server(f: T => S): Server[T, S] = {
val c = open[Req[T, S]]
c.events onEvent {
case (x, ch) => ch ! f(x)
}
c.channel
}
def ?[T, S]
(s: Server[T, S], x: T): Events[S] = {
}
def ?[T, S]
(s: Server[T, S], x: T): Events[S] = {
val reply = open[S]
}
def ?[T, S]
(s: Server[T, S], x: T): Events[S] = {
val reply = open[S]
s ! (x, reply.channel)
}
def ?[T, S]
(s: Server[T, S], x: T): Events[S] = {
val reply = open[S]
s ! (x, reply.channel)
reply.events
}
def ?[T, S]
(s: Server[T, S], x: T): Events[S] = {
val reply = open[S]
s ! (x, reply.channel)
reply.events
}
val data = mutable.Map(1 -> 2, 3 -> 4)
val s = server(data)
def ?[T, S]
(s: Server[T, S], x: T): Events[S] = {
val reply = open[S]
s ! (x, reply.channel)
reply.events
}
val data = mutable.Map(1 -> 2, 3 -> 4)
val s = server(data)
(s ? 1) onEvent { x =>
println(x)
}
type TwoWay[I, O] = (Channel[O], Events[I])
type TwoWay.Req[I, O] =
Req[Channel[I], Channel[O]]
type TwoWay.Req[I, O] =
Req[Channel[I], Channel[O]]
type TwoWay.Server[I, O] =
Server[Channel[I], Channel[O]]
type TwoWay[I, O] = (Channel[O], Events[I])
type TwoWay[I, O] = (Channel[I], Events[O])
def twoWayServer[I, O]:
(TwoWay.Server[I, O], Events[TwoWay[O, I]])
type TwoWay[I, O] = (Channel[I], Events[O])
def twoWayServer[I, O]:
(TwoWay.Server[I, O], Events[TwoWay[O, I]]) = {
val c = open[TwoWay.Req[I, O]]
}
type TwoWay[I, O] = (Channel[I], Events[O])
def twoWayServer[I, O]:
(TwoWay.Server[I, O], Events[TwoWay[O, I]]) = {
val c = open[TwoWay.Req[I, O]]
val connections = c.events map {
case (input, sender) =>
}
}
type TwoWay[I, O] = (Channel[I], Events[O])
def twoWayServer[I, O]:
(TwoWay.Server[I, O], Events[TwoWay[O, I]]) = {
val c = open[TwoWay.Req[I, O]]
val connections = c.events map {
case (input, sender) =>
val output = open[O]
sender ! output.channel
(input, output.events): TwoWay[O, I]
}
}
type TwoWay[I, O] = (Channel[I], Events[O])
def twoWayServer[I, O]:
(TwoWay.Server[I, O], Events[TwoWay[O, I]]) = {
val c = open[TwoWay.Req[I, O]]
val connections = c.events map {
case (input, sender) =>
val output = open[O]
sender ! output.channel
(input, output.events)
}
(c.channel, connections)
}
def connect[I, O](
s: TwoWay.Server[I, O]
): Events[TwoWay[I, O]] = {
}
def connect[I, O](
s: TwoWay.Server[I, O]
): Events[TwoWay[I, O]] = {
val c = open[I]
}
def connect[I, O](
s: TwoWay.Server[I, O]
): Events[TwoWay[I, O]] = {
val c = open[I]
(s ? c) map { output =>
(output, c.events)
}
}
type ReliableChannel[T] =
TwoWay[Stamp, (T, Stamp)]
type ReliableChannel[T] =
TwoWay[Stamp, (T, Stamp)]
type ReliableEvents[T] =
TwoWay[(T, Stamp), Stamp]
def reliable(e: ReliableEvents[T]): Events[T]
def reliable(c: ReliableChannel[T]): Channel[T]
type BackpressureEvents[T] =
(Events[Boolean], Queue[T])
type BackpressureEvents[T] =
(Events[Boolean], Queue[T])
def backpressure[T]
(t: TwoWay[T, Int]): BackpressureEvents[T]
type BackpressureChannel[T] =
(Channel[T], Events[Boolean])
type BackpressureChannel[T] =
(Channel[T], Events[Boolean])
def backpressure[T](t: TwoWay[Int, T]):
BackpressureChannel[T]
Channel[TwoWay.Server[Int, T]]
type Stream[T] =
Channel[TwoWay.Server[Int, T]]
def map[T, S](
s: Stream[T], f: T => S): Stream[S]
def filter[T](
s: Stream[T], f: T => Boolean): Stream[T]
def scanLeft[T,S](
s: Stream[T], z: S,
op: (S, T) => S): Stream[S]
def batch(s: Stream[T], x: Int): Stream[Seq[T]]
def lift[T, S]
(f: Events[T] => Events[S]):
Stream[T] => Stream[S]
1. Backpressure not a core primitive.
2. However, compiler optimizations might be necessary.
Use a spacebar or arrow keys to navigate


This program enocountered a fatal error:
(No Error)
Copy the text below and paste it into your topic's post.


Utopia::Command::Site
Local site setup commands.
Nested
Definitions
CONFIGURATION_FILES = ['.gitignore', 'config.ru', 'config/environment.rb', 'falcon.rb', 'gems.rb', 'Guardfile', 'bake.rb', 'spec/spec_helper.rb', 'spec/website_context.rb', 'spec/website_spec.rb']
Configuration files which should be installed/updated:
DIRECTORIES = ["config", "lib", "pages", "public", "tasks", "spec"]
Directories that should exist:
OLD_PATHS = ["access_log", "cache", "tmp", "Rakefile", "tasks", ".bowerrc"]
Directories that should be removed during upgrade process:
ROOT = File.join(SETUP_ROOT, 'site')
The root directory of the template site:


[]. bats virus human SARS- China SARS coronavirus {border-style px;} #ffffff;} natural SARS-CoV SARS-CoV- Wuhan bamboo bat viruses intermediate online: outbreak February SARS-COV- hosts infection new infected factors genome horseshoe host respiratory Thus, cells conditions epidemics green manuscript. px; rat showed viral wild wildlife {font-family However, Huanan MERS-CoV Seafood cold common different disease drought environmental epidemic font-size humidity novel potential red sequence severe winter Chinese CoVs SARS-like Wuhan, Yangtze [,]. acute areas civet conducive double; identified initial isolated light lights pangolins pneumonia shown social study syndrome December Guangdong Province River Therefore, Zhejiang [], annual attracted beings. border-color border-width breeding carried carry carrying coronaviruses detected habitat humans humans. locations occurred rats recombination single site solid; source spread time various {font-style {font-weight Bats China, Coronavirus Hubei Market Outbreak Potential SARS-CoV-. SARS-CoVs Statistics Virus Weather ability bats. bold causing collected courier; directly dry em; enzyme etiological exposure identity increased infecting low market necessary origin(s) originated patients places pneumoniaâ€� pt;} rainfall rats, receptor related spreading started survival suspected temperature transmission transmitted used uses â€œWuhan


--- layout: page title: Lean Prover Zulip Chat Archive permalink: archive/113488general/06553CheapinstallationideaforWindows.html ---
If I download Lean 3.4.1 and a recent mathlib on a Windows 7 machine, write a careful leanpkg.path, compile everything (i.e. make all the .olean
files), bundle it all up and make it accessible to a bunch of undergraduates who are also using Windows 7 machines, is it likely that they would be able to download and extract this bundle of files and then just have a working Lean and mathlib? In other words, are .olean
files compiled on one machine likely to work on another machine running the same OS?
I think you should try it and find out
I'm not aware of too much experimentation in this area
We really need such a thing to be possible
I might well do this today.
{% endraw %}


abstract val pendingTransactions: Flow<List<PendingTransaction>>
A flow of all the outbound pending transaction that have been sent but are awaiting confirmations.


James is a fourth year computer engineering undergraduate student at the University of California, San Diego with an interest in web development, embedded systems, HCI (recently), and 3D computer graphics.
Above is an in progress 3D threejs scene
This was my group's final project for cogs 121. It is a website that shows users the average housing price per neighborhood in San Diego.
This was my group's project for CSE 145: Embedded Systems. We created a smart shirt that would obtain biometric data on the wearer and send the data to their mobile device. The data would be used by the wearer to track their performance relative to their fiteness goals.


Next: or, Previous: cond, Up: Data and Control Flow Dictionary
if
test-form then-form [else-form] ⇒ {result}*
Test-form—a form.
Then-form—a form.
Else-form—a form. The default is nil.
results—if the test-form yielded true, the values returned by the then-form; otherwise, the values returned by the else-form.
if allows the execution of a form to be dependent on a single test-form.
First test-form is evaluated. If the result is true, then then-form is selected; otherwise else-form is selected. Whichever form is selected is then evaluated.
(if t 1) ⇒ 1 (if nil 1 2) ⇒ 2 (defun test () (dolist (truth-value '(t nil 1 (a b c))) (if truth-value (print 'true) (print 'false)) (prin1 truth-value))) ⇒ TEST (test) |> TRUE T |> FALSE NIL |> TRUE 1 |> TRUE (A B C) ⇒ NIL
(if test-form then-form else-form) ≡ (cond (test-form then-form) (t else-form))


The flow of the simplest CRUD applications can be described using the following steps:
In most cases, there's no reason to make small and medium-sized applications more complicated. But sometimes it's not enough and when our needs become more sophisticated we want to have scalable systems with straightforward data flow.
That's why Nest provides a lightweight CQRS module which components are well-described below.
In order to make the application easier to understand, each change has to be preceded by a Command. When any command is dispatched, the application has to react on it. Commands could be dispatched from the services and consumed in corresponding Command Handlers.
{{ 'heroes-game.service' | extension: heroGameServiceT.isJsActive }}{{ heroGameService }}
{{ heroGameServiceJs }}
Here's a sample service that dispatches KillDragonCommand
. Let's see how the command looks like:
{{ killDragonCommand }}
{{ killDragonCommandJs }}
The CommandBus
is a commands stream. It delegates commands to the equivalent handlers.
Each Command has to have corresponding Command Handler:
{{ killDragonHandler }}
{{ killDragonHandlerJs }}
Now every application state change is a result of the Command occurrence. The logic is encapsulated in handlers. If we want we can simply add logging here or even more, we can persist our commands in the database (e.g. for the diagnostics purposes).
Why do we need resolve()
function? Sometimes we might want to return a message from handler to the service. Also, we can just call this function at the beginning of the execute()
method, therefore the application would first turn back into the service and return a response to the client and then asynchronously come back here to process the dispatched command.
Since we have encapsulated commands in handlers, we prevent interaction between them - the application structure'is still not flexible, not reactive. The solution is to use events.
{{ 'hero-killed-dragon.event' | extension: killedDragonEventT.isJsActive }}{{ killedDragonEvent }}
{{ killedDragonEventJs }}
Events are asynchronous. They are dispatched by models.
Models have to extend the AggregateRoot
class.
{{ heroModel }}
{{ heroModelJs }}
The apply()
method does not dispatch events yet because there's no relationship between model and the EventPublisher
class.
How to tell the model about the publisher? We need to use a publisher mergeObjectContext()
method inside our command handler.
{{ merged }}
{{ mergedJs }}
Now everything works as expected. Notice that we need to commit()
events since they're not dispatched immediately.
Of course, an object doesn't have to exist already. We can easily merge type context also:
{{ mergedType }}
That's it. A model has an ability to publish events now. We have to handle them.
Each event can have a lot of Event Handlers. They don't have to know about each other.
{{ 'hero-killed-dragon.handler' | extension: eventHandlerT.isJsActive }}{{ eventHandler }}
{{ eventHandlerJs }}
Now we can move the write logic into the event handlers.
This type of Event-Driven Architecture improves application reactiveness and scalability. Now, when we have events, we can simply react to them in various manners. The Sagas are the last building block from the architecture point of view.
The sagas are an incredibly powerful feature. Single saga may listen for 1..* events. It can combine, merge, filter [...] events streams. RxJS library is the place where the magic comes from. In simple words, each saga has to return an Observable which contains a command. This command is dispatched asynchronously.
{{ 'heroes-game.saga' | extension: sagaT.isJsActive }}{{ saga }}
{{ sagaJs }}
We declared a rule that when any hero kills the dragon - it should obtain the ancient item.
Then the DropAncientItemCommand
will be dispatched and processed by the appropriate handler.
The last thing which we have to take care of is to set up the whole mechanism.
{{ 'heroes-game.module' | extension: setupT.isJsActive }}{{ setup }}
{{ setupJs }}
Both CommandBus
and EventBus
are Observables.
It means that you can easily subscribe to the whole stream and enrich your application with Event Sourcing.
A working example is available here.


mart
home
about us
page
shop
blog
content us
affordable paris tours
city tours / tour tickets / tour guides
news collection
blue tshirt
$26
ADD TO CART
woman shirt
$31
ADD TO CART
yellow tshirt
$21
ADD TO CART
cool lingerie
$56
ADD TO CART


{% extends "server/index.html" %} {% block body %} {% ifequal trust_root_valid "Valid" %}
The site {{ trust_root|escape }} has requested verification of your OpenID.
{% include "server/pape_request_info.html" %} {% endifequal %} {% ifequal trust_root_valid "Invalid" %}This request claims to be from {{ trust_root|escape }} but I have determined that it is a pack of lies. Beware, if you release information to them, they are likely to do unconscionable things with it, being the lying liars that they are.
Please tell the real {{ trust_root|escape }} that someone is trying to abuse your trust in their good name.
The site {{ trust_root|escape }} has requested verification of your OpenID. I have failed to reach it and thus cannot vouch for its authenticity. Perhaps it is on your local network.
{% endifequal %} {% ifequal trust_root_valid "DISCOVERY_FAILED" %}The site {{ trust_root|escape }} has requested verification of your OpenID. However, {{ trust_root|escape }} does not implement OpenID 2.0's relying party verification mechanism. Please use extra caution in deciding whether to release information to this party, and ask {{ trust_root|escape }} to implement relying party verification for your future transactions.
{% include "server/pape_request_info.html" %} {% endifequal %}


You'll never know if you don't go (GO!)  That's the way I like it And I never get bored Somebody once asked, 'Could you spare some change for gas? I need to get myself away from this place' I said yep what a concept I could use a little fuel myself And we could all use a little change REPEAT CHORUS |


Sign in to continue to Dastone.
Don't have an account ? Free Resister
Already have an account ?Log in


Anytime is Train Time
Current Train Schedule
Train Name
Destination
Frequency (min)
Next Arrival
Minutes Away
Train Name
Destination
First Train Time (HH:mm - military time)
Frequency (min)
Submit


Generative modeling among creative systems has research interest in a wide variety of tasks. Just as deep learning has reshaped the whole field of artificial intelligence, it has reinvented generative modeling in recent years. However even with the research interest in generative systems, the assessment and evaluation of such systems has proven challenging.
In the recent research of music generation, various data-driven models have shown promising results. As a quick example, here are two generated samples from two distinct system:
Now, how can we analyze and compare the behavior of these models?
As the ultimate judge of creative output is the human (listener or viewer), subjective evaluation is generally preferable in generative modeling. However, the general drawbacks of subjective evaluation can be summarized as various issues related to the required amount of resources and to the experiment design. Yet, objective evaluation plays an important roll of providing a systematic measurement across the significant amount of samples in the data-driven approach.
The proposed evaluation strategy
The proposed method does not aim at assessing musical pieces in the context of human-level creativity nor does it attempt to model the aesthetic perception of music.
It rather applies the concept of multi-criteria evaluation in order to provide metrics that assess basic technical properties of the generated music and help researchers identify issues and specific characteristics of both model and dataset.
For the very first step, we define two collections of samples as our input datasets (For the application of objective evaluation, one dataset contains generated samples, the other contains samples from the training dataset). Then, we extract a set of musical domain-knowledge based features for two main targets of the proposed evaluation strategy:
Absolute measurements
Absolute measurements give insights into properties and characteristics of a generated or collected set of data.
During the model design phase of a generative system, it can be of interest to investigate absolute metrics from the output of different system iterations or of datasets as opposed to a relative evaluation. A typical example is the comparison of the generated results from two generative systems: although the model properties cannot be determined precisely for a data-driven approach, the observation of the generated samples can justify or invalidate a system design.
For instance, an absolute measurement can be a statistic analysis of note length transition histogram of each sample of a given dataset. In the following figure, we can easily observe the difference of such feature among datasets from two different genre.
Relative measurements
In order to enable the comparison of different sets of data, the relative measure generalizes the result among features with various dimensions.
We first perform pairwise exhaustive cross-validation for each feature and smooth the histogram results into probability density functions (PDFs) for a more generalizable representation. If the cross-validation is computed within one set of data, we will refer to it as intra-set distances. If each sample of one set is compared with all samples of the other set, we call it the inter-set distances.
Finally, we measure the similarity between these distributions for the application of evaluating music generative systems, and compute two metrics between the target dataset’s intra-set PDF and the inter-set PDF: the Kullback-Leibler Divergence (KLD) and overlapped area (OA) of two PDFs.
Take the following visualized figure as an example: assume set1 is the training data, set2 and set3 correspond to generated results from two systems. The analysis can provide a quick observation that the system generates set2 has a closer behavior in such feature with the training data.
Check out more details
Please find our paper for detailed use-case demonstration, and the released toolbox for further application.


Building the simulation side and hooking it up to the MapViewController.
I spent some time setting up unit testing and writing some initial tests. I went with the Nunit framework, and added FluentAssertions to clean things up a little. I picked Nunit because this project is cross platform, and may be built by people without VS, and Nunit seems like the most platform agnostic framework for C#.
Next I started working on building the simulation structure and map generation. I want to allow arbitrarily large maps, which means the world map will be larger than memory. Chunking is the standard approach to handling large map data, just pick a width and height for the chunks and use a little modular math:
...
public Vector GlobalCoord(int x, int y) => GlobalCoord(new Vector(x, y));
public Vector GlobalCoord(Vector loc) => (Index * ChunkSize) + loc;
public static Vector LocalCoord(int x, int y) => LocalCoord(new Vector(x, y));
public static Vector LocalCoord(Vector coord) => coord % ChunkSize;
public static Vector Coord2Chunk(int x, int y) => Coord2Chunk(new Vector(x, y));
public static Vector Coord2Chunk(Vector coord) => coord / ChunkSize;
...
The next key to pseudo-infinite maps is the ability to generate a chunk's contents on demand. This can be achieved by using perlin/simplex noise for map generation. Simplex noise can be sampled with a coordinate, and generates smooth transition gradients between coordinates. By sampling the noise using global coordinates patterns will be consistent across chunk boundaries. This is a pretty standard approach, here is a nice explanation.
I am using the SharpNoise library, mainly because it has a Nuget package. It has a bunch of features I don't need, but the noise modules are really neat. You can tweak and combine noise sources in chains or trees. I plan to have multiple noise sources controlling generation at different scales. One low frequency source could pick biomes, while a finer-grained noises could provide view-scale detail, and yet another could determine the location of structures. For now I am just using a "water-line" to pick between two tiles, and to determine where to place walls:
...
void GenerateCells()
{
double value;
Vector local;
Cell cell;
string floor, fill;
foreach (var global in Rect.Coordinates())
{
local = LocalCoord(global);
value = _noise.GetValue(global.X, global.Y, 0);
floor = (value <= 0.1) ? "Water" : "Brick";
fill = (0.5 <= value && value <= 0.6) ? "Wall" : "";
cell = new Cell(floor, fill);
Cells[local.X, local.Y] = cell;
_cellUpdate.OnNext(new KeyValuePair<Vector, Cell>(global, cell));
}
}
...
I am using a new random seed on every run, here is one generated map (2 chunks):
The random content helped me fix a few bugs in my data definitions. I may still need to specialize tile picking per feature type though. There are some problems that are particular to the water pits.
Anyway, the tricky part was connecting the simulation data to the view. Data has
to flow in two directions, first the visible area needs to trigger chunk-loading,
then loaded chunks need to signal their contents and any changes. I already had
a Viewport
in the control layer which knows where the view is looking in
simulation coordinates. I didn't want the viewport to know anything about chunks
though, so I added a LoadArea
method to the SimulationManager
that
determines which chunks to load.
Going the other direct I at first was publishing a WhenChunkUpdates
observable,
but again I didn't want the Controller to know anything about chunks. Also
sending entire chunks on every update (even if only a single cell changed)
seemed pretty wasteful. Instead I exposed a WhenCellUpdates
observable on the
SimulationManager
that aggregates events from similar observables in each
loaded chunk. The viewport then filters through the cell updates and processes
any that overlap with it.
I have the viewport pushing update events every time a change is successfully
processed. This flow is optimal for single cell updates (i.e. when something
moves in the simulation) but is really bad for initial loading. Especially since
I am still pushing the entire viewport map on every update. I was going to do
by-tile updates to the view, but I'm not storing intermediate tile data so I
can't do piecewise tile resolution. It isn't that bad though because ReactiveX
provides a Throttle
extension method that ignores observable changes until
update speed falls below a set frequency:
...
public IView CreateMapView(MapViewController ctrl)
{
var view = new MapView(_screen, Width, Height);
Add(view);
// Setup controller viewport
var vp = ctrl.AddViewport(new Rect(0, 0, view.Width, view.Height));
// Bind events
ctrl.WhenAddTileKey.Subscribe(view.AddTileKey);
ctrl.Initialize();
vp.WhenMapChanges
.Throttle(new TimeSpan((1/60)*1000))
.Subscribe(view.UpdateMap);
vp.Initialize();
return view;
}
...
The next steps are to elaborate the cell data structure, create chunk generation infrastructure, and add simulation entities.
GitHub commit e741b36f3.


Eliza Dushku
Eliza Dushku was born in Boston, Massachusetts, to Judith (Rasmussen), a political science professor, and Philip R. Dushku, a teacher and administrator. Her father is Albanian and her mother is American (of Danish, Irish, English, and German descent). She was discovered at the end of a five-month search throughout the United States for the perfect See full bio
Born: December 30, 1980 in Boston, Massachusetts, USA
7 nominations. See more awards
Filmography
Actress(62 credits)
Eloise 2017/I
Pia Carter
Con Man(TV Series) 2016
Cindy
-
Gum Drop(2016) ... Cindy
Princess Rap Battle(TV Series short)
Rapunzle
Banshee(TV series)
Veronica Dawson
-
Requiem(2016) ... Veronica Dawson
-
Truths Other than the Ones You Tell Yourself(2016) ... Veronica Dawson
-
Only One Way a Dogfight Ends(2016) ... Veronica Dawson
-
A little Late to Grow a Pair(2016) ... Veronica Dawson


Options
Select Times Tables
Factor1 is a random number between 1 and 9 inclusive. Please select the numbers, you'd like to include in the random number generator for Factor2 below:
{{ i }} {{ i }}Format
Factor1 * Factor2 = ?
Factor2 * Factor1 = ?
Factor1 is a random number between 1 and 9 inclusive. Please select the numbers, you'd like to include in the random number generator for Factor2 below:
{{ i }} {{ i }}Factor1 * Factor2 = ?
Factor2 * Factor1 = ?


WerisCheap
Win as One in EA SPORTS™ FIFA 21, powered by Frostbite™. Whether it's on the streets or in the stadium, FIFA 21 has more ways to play than ever before - including the UEFA Champions League and CONMEBOL Libertadores.
$14.88
$29.99
$29.99
$59.99
$59.99
$29.99
System Requirements
Minumum
Requires a 64-bit processor and operating system
OS: Windows 10 - 64-Bit
Processor: Intel Core i3-6100 @ 3.7GHz or AMD Athlon X4 880K @4GHz
Memory: 8 GB RAM
Graphics: NVIDIA GTX 660 2GB or AMD Radeon HD 7850 2GBStorage: 50 GB available space
Storage: 50 GB available space
Recommended
Requires a 64-bit processor and operating system
OS: Windows 10 - 64-Bit
Processor: Intel i5-3550 @ 3.40GHz or AMD FX 8150 @ 3.6GHz
Memory: 8 GB RAM
Graphics: NVIDIA GeForce GTX 670 or AMD Radeon R9 270X
Network: Broadband Internet connection
Storage: 50 GB available space


Max Payson
slides: http://bit.ly/ed-open-house
Image Credits: Foreside , Harkness Table , Yale
"GroundVu's 360-degree images provided us with an address-level view of the front of people's houses and allowed us to estimate the amount of water in each home"
"MetroTech converted our traffic cameras into 24 x 7 count stations, providing us with enhanced traffic data. From this data, we were able to improve our signal timing, mitigating overall congestion"
“DataCapable listened to our specific needs and developed the software that will add value to any utility looking to engage its customers with digital tools.”
Esri Staff
Community Resources
Create street-level photos for extracting geospatial data with computer vision
Groundbreaking visualization platform for spatially referenced data


This is a simple WISE4-like MySystem container. Try manipulating the system diagram, taking snapshots as you go, and then select some old snapshots from the dropdown menu.


Last updated: December 30, 2015
Pexels GmbH ("us", "we", or "our") operates the https://www.pexels.com/ website (the "Service").
This page informs you of our policies regarding the collection, use and disclosure of Personal Information when you use our Service.
We will not use or share your information with anyone except as described in this Privacy Policy.
We use your Personal Information for providing and improving the Service. By using the Service, you agree to the collection and use of information in accordance with this policy. Unless otherwise defined in this Privacy Policy, terms used in this Privacy Policy have the same meanings as in our Terms and Conditions, accessible at https://www.pexels.com/
Information Collection And Use
While using our Service, we may ask you to provide us with certain personally identifiable information that can be used to contact or identify you. Personally identifiable information may include, but is not limited to, your email address, name, other information ("Personal Information").
Log Data
We collect information that your browser sends whenever you visit our Service ("Log Data"). This Log Data may include information such as your computer's Internet Protocol ("IP") address, browser type, browser version, the pages of our Service that you visit, the time and date of your visit, the time spent on those pages and other statistics.
In addition, we may use third party services such as Google Analytics that collect, monitor and analyze this type of information in order to increase our Service's functionality. These third party service providers have their own privacy policies addressing how they use such information.
Cookies
Cookies are files with small amount of data, which may include an anonymous unique identifier. Cookies are sent to your browser from a web site and stored on your computer's hard drive.
We use "cookies" to collect information. You can instruct your browser to refuse all cookies or to indicate when a cookie is being sent. However, if you do not accept cookies, you may not be able to use some portions of our Service.
Service Providers
We may employ third party companies and individuals to facilitate our Service, to provide the Service on our behalf, to perform Service-related services or to assist us in analyzing how our Service is used.
These third parties have access to your Personal Information only to perform these tasks on our behalf and are obligated not to disclose or use it for any other purpose.
Communications
We may use your Personal Information to contact you with newsletters, marketing or promotional materials and other information that may be of interest to you. You may opt out of receiving any, or all, of these communications from us by following the unsubscribe link or instructions provided in any email we send or by contacting us.
Security
The security of your Personal Information is important to us, but remember that no method of transmission over the Internet, or method of electronic storage is 100% secure. While we strive to use commercially acceptable means to protect your Personal Information, we cannot guarantee its absolute security.
International Transfer
Your information, including Personal Information, may be transferred to — and maintained on — computers located outside of your state, province, country or other governmental jurisdiction where the data protection laws may differ than those from your jurisdiction.
If you choose to provide information to us, please note that we transfer the information, including Personal Information, to other countries and process it there.
Your consent to this Privacy Policy followed by your submission of such information represents your agreement to that transfer.
Links To Other Sites
Our Service may contain links to other sites that are not operated by us. If you click on a third party link, you will be directed to that third party's site. We strongly advise you to review the Privacy Policy of every site you visit.
We have no control over, and assume no responsibility for the content, privacy policies or practices of any third party sites or services.
Children's Privacy
Our Service does not address anyone under the age of 13 ("Children").
We do not knowingly collect personally identifiable information from children under 13. If you are a parent or guardian and you are aware that your Children has provided us with Personal Information, please contact us. If we become aware that we have collected Personal Information from a children under age 13 without verification of parental consent, we take steps to remove that information from our servers.
Changes To This Privacy Policy
We may update our Privacy Policy from time to time. We will notify you of any changes by posting the new Privacy Policy on this page.
You are advised to review this Privacy Policy periodically for any changes. Changes to this Privacy Policy are effective when they are posted on this page.
Contact Us
If you have any questions about this Privacy Policy, please contact us.