Spring Boot with Spring Security and H2
Simple Secured Endpoint
Principal
page
H2 Console
page (public)
jdbcTemplateData
page
Logout


Text to Save:
Reload
Save
Clear
Filename to Save As:
Save Text to File
Select a File to Load:
Load Selected File


General Election 2019: These are the candidates standing in West Lancashire
by Colin AinscoughCampaigning is well underway as the country prepares to go to the polls in a snap General Election on Thursday, December 12.
These are the confirmed candidates standing in West Lancashire.
Rosie Cooper - Labour
Jack Gilmore - Conservative Pary
Simon Paul Thomson - Liberal Democrats
John Richard Puddifer - Green Party
Marc Stanton - Brexit Party


{% extends "cctbx/header.html" %} {% load static %} {% block extra_js %} {% endblock extra_js %} {% block content %}
This script shows how to use the LBFGS minimizer without curvatures (gradients only), with and without bounds.
Authors: Pavel V. Afonine, Dorothee Liebschner
The limited-memory Broyden–Fletcher–Goldfarb–Shanno (LBFGS) algorithm is an optimization method to find the minimum of a function f(x), with x being a vector in \( \mathbb{R}^3 \) and f(x) a differentiable function.
The basic idea of minimization algorithms is to find iteratively the minimum of a function \( f(x) \). For example, the gradient descent method starts off at a random initial point \( f(x_0) \) and iteratively takes steps that are proportional to the negative gradient of \( f(x) \) at the current point. As this is quite inefficient (a lot of iterations are required to find the minimum), the second order behavior (second derivatives = curvatures) can be used in addition. This is the Newton method, where the iterative scheme is given by:
\begin{equation} x_{k+1} = x_k - [H(x_k)]^{-1} \nabla f(x_k) \end{equation}The Newton method is quite efficient, but it is computational expensive to calculate the inverse of the Hessian matrix. This is where the BFGS algorithm kicks in: Instead of explicitly calculating the second derivates, it uses approximations of the Hessian matrix to converge faster. At each iteration k+1, an approximate inverse second derivative is calculated using quantities from previous steps (the first derivative from the previous two iterations k and k−1):
\begin{equation} x_{k+1} = x_k - f^\prime(x_k) \frac{x_k-x_{k-1}}{f^\prime(x_k) - f^\prime(x_k-1)} \end{equation}The L-BFGS algorithm is an approximation of the BFGS procedure. It uses a limited amount of computer memory.
L-BFGS does not use boundaries as it was developed to solve unconstrained optimization problems. However, there is an extension of L-BFGS, called L-BFGS-B (Zhu et al., 1997), that can handle simple bounds. Both options are available in the cctbx.
Generally, the gradient based optimizers have a larger convergence radius but have a harder time to approach the minimum.
Second derivative based minimizers have much smaller convergence radius, but if you are close enough to the minimum, they can get there much more efficiently.
Therefore it is best to use both: when you are far from minimum, use gradient based minimizers, and once you are close enough switch to use 2nd derivatives. However, this option is not available in the cctbx.
Further reading:
The Rosenbrock function is a test function for evaluate the performance of optimization algorithms, such as convergence rate,
precision and robustness.
Simple functions like this are useful to debug and test new algorithms as they are fast to implement and to execute. If the algorithm does not perform well on this standard problem, it indicates that it most likely won't work well on real life problems.
It is defined by:
The partial derivatives are:
\begin{equation} \frac{\partial f(x,y)}{\partial x} = -2a + 2x - 4bxy + 4bx^3 \end{equation} \begin{equation} \frac{\partial f(x,y)}{\partial y} = 2by - 2bx^2 \end{equation}To find the global minimum, we set the partial derivatives to 0. Equation (5) gives the condition \( y = x^2 \). Inserting this into equation (4) gives the coordinates of the global minimum: \( x = a \), \( y = a^2 \).
The code below will compute the minimum of the Rosenbrock function with parameters a = 20 and b = 10: \( f(x,y) = (20-x)^2 +10(y-x^2)^2 \)
from __future__ import division, print_function
from scitbx.array_family import flex
from libtbx import adopt_init_args
import scitbx.lbfgs
from scitbx import lbfgsb
class rosenbrock(object):
def __init__(self, a, b, x):
adopt_init_args(self, locals())
assert self.x.size() == 2
def update(self, x):
self.x = x
assert self.x.size() == 2
def target(self):
return (self.a-self.x[0])**2+self.b*(self.x[1]-self.x[0]**2)**2
def gradients(self):
g1 = 2*(self.x[0]-self.a) + 4*self.b*(self.x[0]**3-self.x[0]*self.x[1])
g2 = 2*self.b*(self.x[1]-self.x[0]**2)
return flex.double([g1,g2])
def lbfgs_run(target_evaluator, use_bounds, lower_bound, upper_bound):
minimizer = lbfgsb.minimizer(
n = target_evaluator.n,
l = lower_bound, # lower bound
u = upper_bound, # upper bound
nbd = flex.int(target_evaluator.n, use_bounds)) # flag to apply both bounds
minimizer.error = None
try:
icall = 0
while 1:
icall += 1
x, f, g = target_evaluator()
have_request = minimizer.process(x, f, g)
if(have_request):
requests_f_and_g = minimizer.requests_f_and_g()
continue
assert not minimizer.requests_f_and_g()
if(minimizer.is_terminated()): break
except RuntimeError as e:
minimizer.error = str(e)
minimizer.n_calls = icall
return minimizer
class minimizer_bound(object):
def __init__(self,
calculator,
use_bounds,
lower_bound,
upper_bound,
initial_values):
adopt_init_args(self, locals())
self.x = initial_values
self.n = self.x.size()
def run(self):
self.minimizer = lbfgs_run(
target_evaluator=self,
use_bounds=self.use_bounds,
lower_bound = self.lower_bound,
upper_bound = self.upper_bound)
self()
return self
def __call__(self):
self.calculator.update(x = self.x)
self.f = self.calculator.target()
self.g = self.calculator.gradients()
return self.x, self.f, self.g
class minimizer_unbound(object):
#
def __init__(self, max_iterations, calculator):
adopt_init_args(self, locals())
self.x = self.calculator.x
self.minimizer = scitbx.lbfgs.run(
target_evaluator=self,
termination_params=scitbx.lbfgs.termination_parameters(
max_iterations=max_iterations))
def compute_functional_and_gradients(self):
self.calculator.update(x = self.x)
t = self.calculator.target()
g = self.calculator.gradients()
return t,g
def run():
# Instantiate rosenbrock class
calculator = rosenbrock(a = 20, b = 10, x = flex.double([0,0]))
#
print('Run L-BFGS (no boundaries)')
m_unbound = minimizer_unbound(max_iterations=100, calculator=calculator)
print('\tMinimum: ', list(m_unbound.x))
print()
print('Run L-BFGS-B with boundaries')
m_bound = minimizer_bound(
calculator = calculator,
use_bounds = 2,
lower_bound = flex.double([-10000,-10000]),
upper_bound = flex.double([10000,10000]),
initial_values = flex.double([0,0])).run()
print('\tMinimum: ', list(m_bound.x))
if (__name__ == "__main__"):
run()
The script consists of several parts:
Imports: At the beginning of the script are import statements. They are used to import the modules needed for a task.
Main function: The run()
function is used to call the minimizer and to print the result to standard output.
class Rosenbrock: The minimizers use this class to compute values and gradients of the Rosenbrock function.
class minimizer_unbound: Class to perform minimization of the Rosenbrock function, without bounds.
class minimizer_bound: Class to perform minimization of the Rosenbrock function, without bounds.
function lbfgs_run Helper function to run the minimizer with bounds. The code could be part of the class but it helps keeping tasks apart by moving it to a separate function.
The minimizer needs a calculator object that represents the function to be minimized. In our example, this is the class rosenbrock()
. The class is initialized in the run()
function with the two parameters a and b and a starting value \( x = (0,0) \):
calculator = rosenbrock(a = 20, b = 10, x = flex.double([0,0]))
Note that x is a two-dimensional array that represents the vector (x,y) in equation (3); so x[0] = x and x[1] = y, if we translate the notation in the code to the notation in the equation.
The update()
method assigns the vector (x,y) as attribute x of the rosenbrock class. We get the current value of x from the minimizer and it is used to calculate the next value of the minimization procedure. After enough iterations, this value should correspond to the minimum of the function.
The target()
method returns the value of the rosenbrock function in equ. (3) calculated at (x,y).
The gradients()
method returns the array of partial derivatives (equations 4 and 5).
The run()
function instantiates the rosenbrock()
class with parameters a=20 and b=10:
calculator = rosenbrock(a = 20, b = 10, x = flex.double([0,0]))
Then it creates the minimizer_unbound()
class:
m_unbound = minimizer_unbound(max_iterations=100, calculator=calculator)
and the minimizer_bound()
class:
m_bound = minimizer_bound(
calculator = calculator,
use_bounds = 2,
lower_bound = flex.double([-10000,-10000]),
upper_bound = flex.double([10000,10000]),
initial_values = flex.double([0,0])).run()
In both cases, thiw will launch the minimization. For both computations, we print the result to standard output.
For minimization without bounds, we will use the minimizer from scitbx.lbfgs
.
First, we initialize the minimizer: We set the starting value (x,y) to the initial value supplied to the rosenbrock class.
self.x = self.calculator.x
In our example, this is \( x = (0,0) \).
Then, we start the minimizer:
self.minimizer = scitbx.lbfgs.run(
target_evaluator=self,
termination_params=scitbx.lbfgs.termination_parameters(
max_iterations=max_iterations))
As the name suggests, the scitbx.lbfgs.termination_parameters
object supplies parameters relevant for decision-making to terminate the minimization. The full set of termination parameters can be found in scitbx/lbfgs/__init__.py. In our example, we only change one parameter, the maximum number of iterations, which we set to 100 when we instantiated the minimizer_unbound()
class in the run()
function.
To perform L-BFGS minimization, we need to calculate the value and the derivative of our function at a point (x,y). this is done in the compute_functional_and_gradients()
method:
def compute_functional_and_gradients(self):
self.calculator.update(x = self.x)
t = self.calculator.target()
g = self.calculator.gradients()
return t,g
This is all we need for minimization without boundaries. The attribute x of the minimizer_unbound()
object will give us the minimum of the Rosenbrock function. Let's print the value in the run()
function:
print('\tMinimum: ', list(m_unbound.x))
Sometimes, the variables of the function to be minimized are not expected to exceed or be inferior to certain values. Then we can use this information and apply boundaries to the minimization procedure. This means we will use the L-BFGS-B algorithm, which is in scitbx:
from scitbx import lbfgsb
The lbfgsb procedure needs to be constructed a bit differently than the lbfgs minimizer, but the principle is the same.
First, we construct the minimizer_bound()
class in the run()
function:
m_bound = minimizer_bound(
calculator = calculator,
use_bounds = 2,
lower_bound = flex.double([-10000,-10000]),
upper_bound = flex.double([10000,10000]),
initial_values = flex.double([0,0])).run()
By providing the parameters for use_bounds
, lower_bound
and upper_bound
, we apply a minimum value of -10,000 and a maximum value of 10,000 for both x and y. Note that we could have chosen different values for each variable.
In the class, the minimizer is first initialized. As in the previous example (minimizer_unbound), the starting value is set to \( x = (0,0) \).
def __init__(self,
calculator,
use_bounds,
lower_bound,
upper_bound,
initial_values):
adopt_init_args(self, locals())
self.x = initial_values
self.n = self.x.size()
The run()
method calls our helper function lbfgs_run()
.
def run(self):
self.minimizer = lbfgs_run(
target_evaluator=self,
use_bounds=self.use_bounds,
lower_bound = self.lower_bound,
upper_bound = self.upper_bound)
self()
return self
The call()
method calculates the function value and the derivatives, a bit like in the compute_functional_and_gradients()
method of the unbound minimizer.
def __call__(self):
self.calculator.update(x = self.x)
self.f = self.calculator.target()
self.g = self.calculator.gradients()
return self.x, self.f, self.g
Let's look at the lbfgs_run()
function. We need to define this additional function because the lbfgsb minimizer does not take an evaluator class as input. Instead, we have to provide the variable, its function value and the gradient explicitly:
have_request = minimizer.process(x, f, g)
The rest of the code in the try-except part handles errors and makes sure the minimizer stops when appropriate, according to termination parameters.
Let's have a look at the output from running the script. We know that the minimum of the Rosenbrock function is at \( x = a \), \( y = a^2 \), so in our example, it is at \( (x,y) = (20, 400) \). The value of the function at this point is 0. The lbfgs minimizer script with our parameters gives:
Run L-BFGS (no boundaries)
Minimum: [19.99999855596643,<PHONE_NUMBER>9915264]
Run L-BFGS-B with boundaries
Minimum: [19.99999999985263,<PHONE_NUMBER>940399]
The values are very close to the analytical value. Both algorithms converged to the minimum.
We can also quickly check how the minimization progresses. For example for the L-BFGS-B method, by adding a print statement at the end of the while loop in the lbfgs_run()
function, we get the current values of f(x,y), i.e. the current value of the Rosenbrock function during the minimization. We can then plot the target value as a function of iterations for each method:
In our example, the L-BFGS minimizer without bounds converged after 59 iterations, while the L-BFGS-B minimizer finished after 64 iterations. For both methods, the minimization progresses in a similar fashion.


light weight, easy, absolutely s*** name but does the job
<script defer>
var searchParams = {
id: "#search",
server: "https://FB-SERVER/s/suggest.json?collection=COLLECTION&show=10&partial_query="
};
autocomplyeet(searchParams);
</script>


"x" "1" "GLATT,H, MUTAGENICITY SPECTRA IN SALMONELLA TYPHIMURIUM STRAINS OFGLUTATHIONE, L-CYSTEINE AND ACTIVE OXYGEN SPECIES, MUTAGENESIS 4(3):221-227,1989"


Latest Articles
Authentic advice from real people on living your best life.
{{ $pag := .Paginate (where .Data.Pages "Type" "post") }} {{ range $pag.Pages }}
{{ partial "article_card_preview.html" . }}
{{ end }}
Read More


Welcome to the experiment!
On every trial you'll see a color word (e.g., "red", "green") in a colored font (e.g., "red", "red")
Your task is to ignore the word and identify the color of the font.
Use the keyboard to make your response:
Press "R" if the color is red, "B" if the color is blue, "G" if the color is green, or "Y" if the color is yellow. Try answer as quickly and as accurately as possible.
Press the "start" button to begin the first trial.


Membership (General)
Save
Cancel
General
Email
Default membership
Free
Default duration
3-months
After expiry of default
De-activate the membership
Auto upgrade the same membership
After expiry of non default
Auto upgrade into default
De-activate the membership
Send auto notification after upgrading the package
Yes
Package upgrade template
Membership upgrade notification template 1
Send auto notification into vendor through email about the expiry
Yes
Auto notification email template
Membership expiry notification template 1
Send manual notification into vendor through email about the expiry
Yes
Manual notification email template
Membership expiry notification template 2
Send notification by email through email after expired by default
Yes
Template for default expired
Membership expiry notification template 3
Send notification by email through email after expired from upgraded package
Yes
Template for upgrade package get expired
Membership expiry notification template 4
2
3


The Boring Podcast - Episode 2 - More
This is really just test audio
Welcome to another episode of The Boring Podcast. This is still awfully dull.
This is really just test audio
Welcome to another episode of The Boring Podcast. This is still awfully dull.
In which we introduce The Boring Podcast
Welcome to The Boring Podcast. Nothing exciting is discussed here.


Sometimes, we found a good article and want to resteem it in our blog.
It’s very easy to do it with steemit.com, just click resteem button under the article, all things done!
But if the article was posted before 7 days, things are different, we CAN NOT find out resteem button at all.
What? Where is the resteem button? How to resteem this article? Do you feel depressed when you find a good article but you can’t resteem it?
Now, Let’s say goodbye to this situation! With SteemConnect, we can resteem any article which posted any time! And most importantly, it’s very convenient and safe enough.
Now, let’s begin.
Steps
First, open the article in browser, so we can get the URL of it.
For example, the article made by @ned 8 days ago, the URL is:https://steemit.com/smt/@ned/smts-explainer-centralized-vs-decentralized-blockchain-rewards-copyright-rev-shares-video
There are several parts in that URL, but there are only two parts we need to concern about:
The auhour:ned
The Permlink:smts-explainer-centralized-vs-decentralized-blockchain-rewards-copyright-rev-shares-video
Now, our hero debut.
Openhttps://v2.steemconnect.com/sign/
SelectReblog
Complete this form with the information we got in previous step.
Click the blue button to generate link and we got following result.
Click TRY LINK button, it will take us to a confirm page.
Click CONTINUE button, it will take us to a log in page.
(Keep in mind: Confirm that you are on steemconnect.com before entering your password)Log in with your steemit account and posting private key
(Keep in mind: Always use posting private key instead of password)Click SIGN IN button to finish this opration
Check our blog
Wow, we resteemed the article made by @ned 8 days ago successfully.
Conclusion
With SteemConnect, It’s very easy to reblog/resteem articles which posted 7 days ago.
Now, let’s reblog/resteem good articles we indeed like.😀
中文版
我们经常发现一些精彩文章想转发。在STEEMIT上只需按文章底部的转发按钮即可。但是对于发表时间7天以上的文章，转发按钮消失了。是不是这样就没法转发了呢？眼看着精彩文章无法转发，是不是很闹心？
别急，用SteemConnect可以转发任何时间内发表的文章，并且安全快捷！
操作步骤见英文部分。
需要注意两点：
- 确保你登陆的是SteemConnect
- 转发文章使用Posting 私钥即可，不要用密码
(封面图源 ：pixabay)
This page is synchronized from the post: 📌 How to reblog/resteem articles which posted 7 days ago with SteemConnect? / 使用SteemConnect转发7天以上的文章


|
HE_Mesh
6.0.1
|
Public Member Functions | |
| WB_Ray () | |
| WB_Ray (final WB_Coord o, final WB_Coord d) | |
| WB_Ray (final double ox, final double oy, final double oz, final double dx, final double dy, final double dz) | |
| String | toString () |
| void | set (final WB_Coord o, final WB_Coord d) |
| void | setFromPoints (final WB_Coord p1, final WB_Coord p2) |
| WB_Point | getPoint (final double t) |
| void | getPointInto (final double t, final WB_MutableCoord p) |
| WB_Point | getParametricPoint (final double t) |
| void | getParametricPointInto (final double t, final WB_MutableCoord p) |
| WB_Coord | getOrigin () |
| WB_Coord | getDirection () |
| WB_Point | curvePoint (final double u) |
| WB_Vector | curveDirection (final double u) |
| WB_Vector | curveDerivative (final double u) |
| double | getLowerU () |
| double | getUpperU () |
| boolean | equals (final Object o) |
| int | hashCode () |
| Public Member Functions inherited from wblut.geom.WB_Line | |
| WB_Line () | |
| WB_Line (final WB_Coord o, final WB_Coord d) | |
| WB_Line (final double ox, final double oy, final double oz, final double dx, final double dy, final double dz) | |
| WB_Line (final double ox, final double oy, final double dx, final double dy) | |
| String | toString () |
| void | setFromPoints (final WB_Coord p1, final WB_Coord p2) |
| double | getT (final WB_Coord p) |
| WB_Point | curvePoint (final double u) |
| WB_Vector | curveDirection (final double u) |
| WB_Vector | curveDerivative (final double u) |
| double | getLowerU () |
| double | getUpperU () |
| double | a () |
| double | b () |
| double | c () |
| WB_Coord | getDirection () |
| WB_Vector | getNormal () |
| WB_Coord | getOrigin () |
| WB_Point | getParametricPoint (final double t) |
| void | getParametricPointInto (final double t, final WB_MutableCoord result) |
| WB_Point | getPoint (final double t) |
| void | getPointInto (final double t, final WB_MutableCoord result) |
| boolean | equals (final Object o) |
| int | hashCode () |
| Public Member Functions inherited from wblut.geom.WB_Curve | |
| WB_Point | curvePoint (double u) |
| WB_Vector | curveDirection (double u) |
| WB_Vector | curveDerivative (double u) |
Static Public Member Functions | |
| static WB_Ray | X () |
| static WB_Ray | Y () |
| static WB_Ray | Z () |
| Static Public Member Functions inherited from wblut.geom.WB_Line | |
| static WB_Line | X () |
| static WB_Line | Y () |
| static WB_Line | Z () |
Additional Inherited Members | |
| Protected Member Functions inherited from wblut.geom.WB_Line | |
| void | set (final WB_Coord o, final WB_Coord d) |
| Protected Attributes inherited from wblut.geom.WB_Line | |
| WB_Point | origin |
| WB_Vector | direction |
| wblut.geom.WB_Ray.WB_Ray | ( | ) |
References wblut.geom.WB_Line.direction, and wblut.geom.WB_Line.origin.
| o | |
| d |
References wblut.geom.WB_Line.direction, wblut.geom.WB_Vector.normalizeSelf(), and wblut.geom.WB_Line.origin.
| wblut.geom.WB_Ray.WB_Ray | ( | final double | ox, |
| final double | oy, | ||
| final double | oz, | ||
| final double | dx, | ||
| final double | dy, | ||
| final double | dz | ||
| ) |
| ox | |
| oy | |
| oz | |
| dx | |
| dy | |
| dz |
References wblut.geom.WB_Line.direction, wblut.geom.WB_Vector.normalizeSelf(), and wblut.geom.WB_Line.origin.
| WB_Vector wblut.geom.WB_Ray.curveDerivative | ( | final double | u | ) |
References wblut.geom.WB_Line.direction.
| WB_Vector wblut.geom.WB_Ray.curveDirection | ( | final double | u | ) |
References wblut.geom.WB_Line.direction.
| WB_Point wblut.geom.WB_Ray.curvePoint | ( | final double | u | ) |
References wblut.geom.WB_Ray.getPoint().
| boolean wblut.geom.WB_Ray.equals | ( | final Object | o | ) |
| WB_Coord wblut.geom.WB_Ray.getDirection | ( | ) |
References wblut.geom.WB_Line.direction.
| double wblut.geom.WB_Ray.getLowerU | ( | ) |
Implements wblut.geom.WB_Curve.
| WB_Coord wblut.geom.WB_Ray.getOrigin | ( | ) |
References wblut.geom.WB_Line.origin.
| WB_Point wblut.geom.WB_Ray.getParametricPoint | ( | final double | t | ) |
| void wblut.geom.WB_Ray.getParametricPointInto | ( | final double | t, |
| final WB_MutableCoord | p | ||
| ) |
| WB_Point wblut.geom.WB_Ray.getPoint | ( | final double | t | ) |
| void wblut.geom.WB_Ray.getPointInto | ( | final double | t, |
| final WB_MutableCoord | p | ||
| ) |
| double wblut.geom.WB_Ray.getUpperU | ( | ) |
Implements wblut.geom.WB_Curve.
| int wblut.geom.WB_Ray.hashCode | ( | ) |
| p1 | |
| p2 |
References wblut.geom.WB_Line.direction, wblut.geom.WB_Vector.normalizeSelf(), and wblut.geom.WB_Line.origin.
| String wblut.geom.WB_Ray.toString | ( | ) |
|
static |
References wblut.geom.WB_Ray.WB_Ray().
|
static |
References wblut.geom.WB_Ray.WB_Ray().
|
static |
References wblut.geom.WB_Ray.WB_Ray().


{% autoescape off %}
Dear {{ company.first_name }} {{ company.last_name }}
Your application for the Chemtogether Career Fair on behalf of {{ company.title }} with a {{ company.get_package_display }} on {{ company.get_day_display }} has been accepted. The registration for {{ company.title }} as a participant of the fair is now binding and subject to the Terms of Service (see https://registration.chemtogether.ethz.ch/static/files/tos.pdf) which you accepted during the application process.
In the following, you will find information on your person of contact and a copy of your registration details.
Your person of contact at Chemtogether:
{{ staff.first_name }} {{ staff.last_name }}
{{ staff.email }}
{{ staff.phone_number }}
If you have any requestion or need additional information, please contact {{ staff.first_name }} {{ staff.last_name }}. {{ staff.first_name }} will also get in contact with you as soon as possible.
Copy of your registration details for Chemtogether:
Company Title: {{ company.title }}
Day of Attendance: {{ company.get_day_display }}
Fair Package: {{ company.get_package_display }}
Correspondence Full Name: {{ company.first_name }} {{ company.last_name }}
Correspondence Mail Address: {{ company.email }}
Correspondence Phone Number: {{ company.phone_number }}
Correspondence Language: {{ company.get_language_display }}
Mailing Address: {{ company.mailing_address }}
Billing Address: {{ company.billing_address }}
Comments: {{ company.comments }}
Sincerely,
Chemtogether Registration Platform on behalf of {{ staff.first_name }} {{ staff.last_name }}
{% endautoescape %}


"x" "1" "SCHWEIKL,H SCHMALZ,G AND WEINMANN,W MUTAGENIC ACTIVITY OF STRUCTURALLYRELATED OXIRANES AND SILORANES IN SALMONELLA TYPHIMURIUM, MUTAT. RES.521(1-2):19-27, 2002"