|
sysclass
1.0
|
Classes | |
| class | SystemClass |
| TODO: Documentation of package, class, function. More... | |
Functions | |
| def | ThrowMsg |
| Functions. More... | |
| def | BeVerbose |
| Be Verbose. More... | |
| def | Debug |
| Do debugging. More... | |
| def | ErrorExit |
| Print error message and exit. More... | |
| def | GetSections |
| Get als sections found in the configuration files. More... | |
| def | GetOptions |
| Get options of sections. More... | |
| def | GetValue |
| Get value. More... | |
| def | Verbosity |
| Get/Set verbosity. More... | |
| def | Debugging |
| Get/Set debugging. More... | |
Variables | |
| string | __author__ = "Antonios Dimtsoudis" |
| string | __copyright__ = "Copyright 2014, systemclass" |
| string | __license__ = "MIT" |
| string | __version__ = "0.9" |
| string | __maintainer__ = "Antonios Dimtsoudis" |
| string | __email__ =<EMAIL_ADDRESS>|
| debug | |
| verbose | |
| def systemclass.BeVerbose | ( | self, | |
| output, | |||
header = None |
|||
| ) |
| def systemclass.Debug | ( | self, | |
| klass, | |||
| output, | |||
header = None |
|||
| ) |
Do debugging.
Print given output if debugging is set.
Definition at line 134 of file systemclass.py.
| def systemclass.Debugging | ( | self, | |
setd = None |
|||
| ) |
| def systemclass.ErrorExit | ( | self, | |
| klass, | |||
| output, | |||
header = None |
|||
| ) |
Print error message and exit.
Print the defined error message and exit
Definition at line 154 of file systemclass.py.
| def systemclass.GetOptions | ( | self, | |
section = None |
|||
| ) |
| def systemclass.GetSections | ( | self, | |
cfgfile = None |
|||
| ) |
Get als sections found in the configuration files.
Args: cfgfile - specify configuration file
Definition at line 170 of file systemclass.py.
| def systemclass.GetValue | ( | self, | |
| value, | |||
section = None |
|||
| ) |
Get value.
Try to get value from given data Order: cmdline --> defined section --> main section
Definition at line 191 of file systemclass.py.
| def systemclass.ThrowMsg | ( | self, | |
| output, | |||
header = None , |
|||
msgtype = "WARNING" |
|||
| ) |
Functions.
TODO: Implement logging in sysclass Throw out message
Throw out message, no matter if verbosity or debugging is set
Definition at line 102 of file systemclass.py.
| def systemclass.Verbosity | ( | self, | |
setv = None |
|||
| ) |
| string systemclass.__author__ = "Antonios Dimtsoudis" |
Definition at line 9 of file systemclass.py.
| string systemclass.__copyright__ = "Copyright 2014, systemclass" |
Definition at line 10 of file systemclass.py.
| string systemclass.__email__ =<EMAIL_ADDRESS>|
Definition at line 14 of file systemclass.py.
| string systemclass.__license__ = "MIT" |
Definition at line 11 of file systemclass.py.
| string systemclass.__maintainer__ = "Antonios Dimtsoudis" |
Definition at line 13 of file systemclass.py.
| string systemclass.__version__ = "0.9" |
Definition at line 12 of file systemclass.py.
| systemclass.debug |
Definition at line 157 of file systemclass.py.
| systemclass.verbose |
Definition at line 224 of file systemclass.py.


Modules in pybert package¶
pybert - Main PyBERT class definition, as well as some helper classes.¶
Bit error rate tester (BERT) simulator, written in Python.
Original Author: David Banas<EMAIL_ADDRESS>Original Date: 17 June 2014
Testing by: Mark Marlett<EMAIL_ADDRESS>This Python script provides a GUI interface to a BERT simulator, which can be used to explore the concepts of serial communication link design.
Copyright (c) 2014 by David Banas; All rights reserved World wide.
-
class
pybert.pybert.
StoppableThread
[source]¶ Thread class with a stop() method.
The thread itself has to check regularly for the stopped() condition.
All PyBERT thread classes are subclasses of this class.
-
class
pybert.pybert.
TxOptThread
[source]¶ Used to run Tx tap weight optimization in its own thread, in order to preserve GUI responsiveness.
-
class
pybert.pybert.
RxOptThread
[source]¶ Used to run Rx tap weight optimization in its own thread, in order to preserve GUI responsiveness.
-
class
pybert.pybert.
CoOptThread
[source]¶ Used to run co-optimization in its own thread, in order to preserve GUI responsiveness.
-
class
pybert.pybert.
TxTapTuner
(name='(noname)', enabled=False, min_val=0.0, max_val=0.0, value=0.0, steps=0)[source]¶ Object used to populate the rows of the Tx FFE tap tuning table.
-
class
pybert.pybert.
PyBERT
(run_simulation=True)[source]¶ A serial communication link bit error rate tester (BERT) simulator with a GUI interface.
Useful for exploring the concepts of serial communication link design.
-
R0
= None¶ Channel skin effect resistance (Ohms/m).
-
Rdc
= None¶ Channel d.c. resistance (Ohms/m).
-
Theta0
= None¶ Channel loss tangent (unitless).
-
Z0
= None¶ Channel characteristic impedance, in LC region (Ohms).
-
Zref
= None¶ Reference (or, nominal) channel impedance.
-
alpha
= None¶ CDR integral branch magnitude (unitless).
-
bit_errs
= None¶ # of bit errors observed in last run.
-
bit_rate
= None¶ (Gbps)
-
cac
= None¶ Rx a.c. coupling capacitance (uF)
-
calc_chnl_h
()[source]¶ Calculates the channel impulse response.
- Also sets, in ‘self’:
- chnl_dly:
group delay of channel
- start_ix:
first element of trimmed response
- t_ns_chnl:
the x-values, in ns, for plotting ‘chnl_h’
- chnl_H:
channel frequency response
- chnl_s:
channel step response
- chnl_p:
channel pulse response
-
cfg_file
= None¶ PyBERT configuration data storage file (File).
-
ch_file
= None¶ Channel file name.
-
chnl_dly
= None¶ Estimated channel delay (s).
-
chnl_valid
= None¶ Channel file is valid.
-
cin
= None¶ Rx parasitic input capacitance (pF)
-
coopt_thread
= None¶ EQ co-optimization thread.
-
cout
= None¶ Tx parasitic output capacitance (pF)
-
ctle_file
= None¶ CTLE response file (when use_ctle_file = True).
-
ctle_mode
= None¶ CTLE mode (‘Off’, ‘Passive’, ‘AGC’, ‘Manual’).
-
ctle_mode_tune
= None¶ EQ optimizer CTLE mode (‘Off’, ‘Passive’, ‘AGC’, ‘Manual’).
-
ctle_offset
= None¶ CTLE d.c. offset (dB)
-
ctle_offset_tune
= None¶ EQ optimizer CTLE d.c. offset (dB).
-
data_file
= None¶ PyBERT results data storage file (File).
-
debug
= None¶ Send log messages to terminal, as well as console, when True. (Default = False)
-
decision_scaler
= None¶ DFE slicer output voltage (V).
-
delta_t
= None¶ CDR proportional branch magnitude (ps).
-
do_sweep
= None¶ Run sweeps? (Default = False)
-
eye_bits
= None¶ # of bits used to form eye. (Default = last 20%)
-
f_step
= None¶ Frequency step to use when constructing H(f). (Default = 10 MHz)
-
gain
= None¶ DFE error gain (unitless).
-
impulse_length
= None¶ Impulse response length. (Determined automatically, when 0.)
-
l_ch
= None¶ Channel length (m).
-
lock_sustain
= None¶ CDR hysteresis to use in determining lock.
-
log
(msg, alert=False, exception=None)[source]¶ Log a message to the console and, optionally, to terminal and/or pop-up dialog.
-
max_iter
= None¶ EQ optimizer max. # of optimization iterations.
-
mod_type
= None¶ 0 = NRZ; 1 = Duo-binary; 2 = PAM-4
-
n_ave
= None¶ DFE # of averages to take, before making tap corrections.
-
n_lock_ave
= None¶ CDR # of averages to take in determining lock.
-
n_taps
= None¶ DFE # of taps.
-
n_taps_tune
= None¶ EQ optimizer # DFE taps.
-
nbits
= None¶ Number of bits to simulate.
-
nspb
= None¶ Signal vector samples per bit.
-
num_sweeps
= None¶ Number of sweeps to run.
-
padded
= None¶ Zero pad imported Touchstone data? (Default = False)
-
pattern_len
= None¶ PRBS pattern length.
-
peak_freq
= None¶ CTLE peaking frequency (GHz)
-
peak_freq_tune
= None¶ EQ optimizer CTLE peaking freq. (GHz).
-
peak_mag
= None¶ CTLE peaking magnitude (dB)
-
peak_mag_tune
= None¶ EQ optimizer CTLE peaking mag. (dB).
-
pn_freq
= None¶ Periodic noise frequency (MHz).
-
pn_mag
= None¶ Periodic noise magnitude (V).
-
rel_lock_tol
= None¶ CDR relative tolerance to use in determining lock.
-
rel_power
= None¶ Tx power dissipation (W).
-
rin
= None¶ Rx input impedance (Ohm)
-
rn
= None¶ Standard deviation of Gaussian random noise (V).
-
rs
= None¶ Tx source impedance (Ohms)
-
rx_ami_file
= None¶ (File)
-
rx_ami_valid
= None¶ (Bool)
-
rx_bw
= None¶ CTLE bandwidth (GHz).
-
rx_bw_tune
= None¶ EQ optimizer CTLE bandwidth (GHz).
-
rx_dll_file
= None¶ (File)
-
rx_dll_valid
= None¶ (Bool)
-
rx_has_getwave
= None¶ (Bool)
-
rx_ibis_file
= None¶ (File)
-
rx_ibis_valid
= None¶ (Bool)
-
rx_opt_thread
= None¶ Rx EQ optimization thread.
-
rx_use_ami
= None¶ (Bool)
-
rx_use_getwave
= None¶ (Bool)
-
rx_use_ibis
= None¶ (Bool)
-
status
= None¶ PyBERT status (String).
-
sum_bw
= None¶ DFE summing node bandwidth (Used when sum_ideal=False.) (GHz).
-
sum_ideal
= None¶ True = use an ideal (i.e. - infinite bandwidth) summing node (Bool).
-
thresh
= None¶ Threshold for identifying periodic jitter components (sigma).
-
tx_ami_file
= None¶ (File)
-
tx_ami_valid
= None¶ (Bool)
-
tx_dll_file
= None¶ (File)
-
tx_dll_valid
= None¶ (Bool)
-
tx_has_getwave
= None¶ (Bool)
-
tx_ibis_file
= None¶ (File)
-
tx_ibis_valid
= None¶ (Bool)
-
tx_opt_thread
= None¶ Tx EQ optimization thread.
-
tx_tap_tuners
= None¶ EQ optimizer list of TxTapTuner objects.
-
tx_taps
= None¶ List of TxTapTuner objects.
-
tx_use_ami
= None¶ (Bool)
-
tx_use_getwave
= None¶ (Bool)
-
tx_use_ibis
= None¶ (Bool)
-
use_ch_file
= None¶ Import channel description from file? (Default = False)
-
use_ctle_file
= None¶ For importing CTLE impulse/step response directly.
-
use_dfe
= None¶ True = use a DFE (Bool).
-
use_dfe_tune
= None¶ EQ optimizer DFE select (Bool).
-
v0
= None¶ Channel relative propagation velocity (c).
-
vod
= None¶ Tx differential output voltage (V)
-
w0
= None¶ Channel transition frequency (rads./s).
-
windowed
= None¶ Apply windowing to the Touchstone data? (Default = False)
-
pybert_cntrl - Model control logic.¶
Default controller definition for PyBERT class.
Original author: David Banas<EMAIL_ADDRESS>Original date: August 24, 2014 (Copied from pybert.py, as part of a major code cleanup.)
Copyright (c) 2014 David Banas; all rights reserved World wide.
-
pybert.pybert_cntrl.
my_run_sweeps
(self)[source]¶ Runs the simulation sweeps.
- Parameters
self (PyBERT) – Reference to an instance of the PyBERT class.
-
pybert.pybert_cntrl.
my_run_simulation
(self, initial_run=False, update_plots=True)[source]¶ Runs the simulation.
- Parameters
self (PyBERT) – Reference to an instance of the PyBERT class.
initial_run (Bool) – If True, don’t update the eye diagrams, since they haven’t been created, yet. (Optional; default = False.)
update_plots (Bool) – If True, update the plots, after simulation completes. This option can be used by larger scripts, which import pybert, in order to avoid graphical back-end conflicts and speed up this function’s execution time. (Optional; default = True.)
pybert_view - Main GUI window layout definition.¶
Default view definition for PyBERT class.
Original author: David Banas<EMAIL_ADDRESS>Original date: August 24, 2014 (Copied from pybert.py, as part of a major code cleanup.)
Copyright (c) 2014 David Banas; all rights reserved World wide.
pybert_util - Various utilities used by other modules.¶
General purpose utilities for PyBERT.
Original author: David Banas<EMAIL_ADDRESS>Original date: September 27, 2014 (Copied from pybert_cntrl.py.)
Copyright (c) 2014 David Banas; all rights reserved World wide.
-
pybert.pybert_util.
moving_average
(a, n=3)[source]¶ Calculates a sliding average over the input vector.
- Parameters
a ([float]) – Input vector to be averaged.
n (int) – Width of averaging window, in vector samples. (Optional; default = 3.)
- Returns
- the moving average of the input vector, leaving the input
vector unchanged.
- Return type
[float]
-
pybert.pybert_util.
find_crossing_times
(t, x, min_delay: float = 0.0, rising_first: bool = True, min_init_dev: float = 0.1, thresh: float = 0.0)[source]¶ Finds the threshold crossing times of the input signal.
- Parameters
t ([float]) – Vector of sample times. Intervals do NOT need to be uniform.
x ([float]) – Sampled input vector.
min_delay (float) – Minimum delay required, before allowing crossings. (Helps avoid false crossings at beginning of signal.) (Optional; default = 0.)
rising_first (bool) – When True, start with the first rising edge found. (Optional; default = True.) When this option is True, the first rising edge crossing is the first crossing returned. This is the desired behavior for PyBERT, because we always initialize the bit stream with [0, 0, 1, 1], in order to provide a known synchronization point for jitter analysis.
min_init_dev (float) – The minimum initial deviation from zero, which must be detected, before searching for crossings. Normalized to maximum input signal magnitude. (Optional; default = 0.1.)
thresh (float) – Vertical crossing threshold.
- Returns
Array of signal threshold crossing times.
- Return type
[float]
-
pybert.pybert_util.
find_crossings
(t, x, amplitude, min_delay: float = 0.0, rising_first: bool = True, min_init_dev=0.1, mod_type=0)[source]¶ Finds the crossing times in a signal, according to the modulation type.
- Parameters
t ([float]) – The times associated with each signal sample.
x ([float]) – The signal samples.
amplitude (float) – The nominal signal amplitude. (Used for determining thresholds, in the case of some modulation types.)
min_delay (float) – The earliest possible sample time we want returned. (Optional; default = 0.)
rising_first (bool) – When True, start with the first rising edge found. When this option is True, the first rising edge crossing is the first crossing returned. This is the desired behavior for PyBERT, because we always initialize the bit stream with [0, 1, 1], in order to provide a known synchronization point for jitter analysis. (Optional; default = True.)
min_init_dev (float) – The minimum initial deviation from zero, which must be detected, before searching for crossings. Normalized to maximum input signal magnitude. (Optional; default = 0.1.)
mod_type (int) – The modulation type. Allowed values are: {0: NRZ, 1: Duo-binary, 2: PAM-4} (Optional; default = 0.)
- Returns
The signal threshold crossing times.
- Return type
[float]
-
pybert.pybert_util.
calc_jitter
(ui, nui, pattern_len, ideal_xings, actual_xings, rel_thresh=6, num_bins=99, zero_mean=True)[source]¶ Calculate the jitter in a set of actual zero crossings, given the ideal crossings and unit interval.
Inputs:
ui : The nominal unit interval.
nui : The number of unit intervals spanned by the input signal.
pattern_len : The number of unit intervals, before input symbol stream repeats.
ideal_xings : The ideal zero crossing locations of the edges.
actual_xings : The actual zero crossing locations of the edges.
rel_thresh : (optional) The threshold for determining periodic jitter spectral components (sigma).
num_bins : (optional) The number of bins to use, when forming histograms.
zero_mean : (optional) Force the mean jitter to zero, when True.
Outputs:
jitter : The total jitter.
t_jitter : The times (taken from ‘ideal_xings’) corresponding to the returned jitter values.
isi : The peak to peak jitter due to intersymbol interference.
dcd : The peak to peak jitter due to duty cycle distortion.
pj : The peak to peak jitter due to uncorrelated periodic sources.
rj : The standard deviation of the jitter due to uncorrelated unbounded random sources.
tie_ind : The data independent jitter.
thresh : Threshold for determining periodic components.
jitter_spectrum : The spectral magnitude of the total jitter.
tie_ind_spectrum : The spectral magnitude of the data independent jitter.
spectrum_freqs : The frequencies corresponding to the spectrum components.
hist : The histogram of the actual jitter.
hist_synth : The histogram of the extrapolated jitter.
bin_centers : The bin center values for both histograms.
-
pybert.pybert_util.
make_uniform
(t, jitter, ui, nbits)[source]¶ Make the jitter vector uniformly sampled in time, by zero-filling where necessary.
The trick, here, is creating a uniformly sampled input vector for the FFT operation, since the jitter samples are almost certainly not uniformly sampled. We do this by simply zero padding the missing samples.
Inputs:
t : The sample times for the ‘jitter’ vector.
jitter : The input jitter samples.
ui : The nominal unit interval.
nbits : The desired number of unit intervals, in the time domain.
Output:
y : The uniformly sampled, zero padded jitter vector.
y_ix : The indices where y is valid (i.e. - not zero padded).
-
pybert.pybert_util.
calc_gamma
(R0, w0, Rdc, Z0, v0, Theta0, ws)[source]¶ Calculates propagation constant from cross-sectional parameters.
The formula’s applied are taken from Howard Johnson’s “Metallic Transmission Model” (See “High Speed Signal Propagation”, Sec. 3.1.)
- Inputs:
R0 skin effect resistance (Ohms/m)
w0 cross-over freq.
Rdc d.c. resistance (Ohms/m)
Z0 characteristic impedance in LC region (Ohms)
v0 propagation velocity (m/s)
Theta0 loss tangent
ws frequency sample points vector
- Outputs:
gamma frequency dependent propagation constant
Zc frequency dependent characteristic impedance
-
pybert.pybert_util.
calc_G
(H, Rs, Cs, Zc, RL, Cp, CL, ws)[source]¶ Calculates fully loaded transfer function of complete channel.
- Inputs:
H unloaded transfer function of interconnect
Rs source series resistance
Cs source parallel (parasitic) capacitance
Zc frequency dependent characteristic impedance of the interconnect
RL load resistance (differential)
Cp load parallel (parasitic) capacitance (single ended)
CL load series (d.c. blocking) capacitance (single ended)
ws frequency sample points vector
- Outputs:
G frequency dependent transfer function of channel
-
pybert.pybert_util.
calc_eye
(ui, samps_per_ui, height, ys, y_max, clock_times=None)[source]¶ Calculates the “eye” diagram of the input signal vector.
- Parameters
ui (float) – unit interval (s)
samps_per_ui (int) – # of samples per unit interval
height (int) – height of output image data array
ys ([float]) – signal vector of interest
y_max (float) – max. +/- vertical extremity of plot
- Keyword Arguments
clock_times ([float]) – (optional) vector of clock times to use for eye centers. If not provided, just use mean zero-crossing and assume constant UI and no phase jumps. (This allows the same function to be used for eye diagram creation, for both pre and post-CDR signals.)
- Returns
- The “heat map” representing the eye diagram. Each grid
location contains a value indicating the number of times the signal passed through that location.
- Return type
2D NumPy array
-
pybert.pybert_util.
make_ctle
(rx_bw, peak_freq, peak_mag, w, mode='Passive', dc_offset=0)[source]¶ Generate the frequency response of a continuous time linear equalizer (CTLE), given the:
signal path bandwidth,
peaking specification
list of frequencies of interest, and
operational mode/offset.
We use the ‘invres()’ function from scipy.signal, as it suggests itself as a natural approach, given our chosen use model of having the user provide the peaking frequency and degree of peaking.
That is, we define our desired frequency response using one zero and two poles, where:
- The pole locations are equal to:
the signal path natural bandwidth, and
the user specified peaking frequency.
The zero location is chosen, so as to provide the desired degree of peaking.
Inputs:
rx_bw The natural (or, unequalized) signal path bandwidth (Hz).
- peak_freq The location of the desired peak in the frequency
response (Hz).
peak_mag The desired relative magnitude of the peak (dB). (mag(H(0)) = 1)
w The list of frequencies of interest (rads./s).
- mode The operational mode; must be one of:
‘Off’ : CTLE is disengaged.
‘Passive’: Maximum frequency response has magnitude one.
‘AGC’ : Automatic gain control. (Handled by calling routine.)
‘Manual’ : D.C. offset is set manually.
- dc_offset The d.c. offset of the CTLE gain curve (dB).
(Only valid, when ‘mode’ = ‘Manual’.)
Outputs:
- w, H The resultant complex frequency response, at the
given frequencies.
-
pybert.pybert_util.
trim_impulse
(g, min_len=0, max_len=1000000)[source]¶ - Trim impulse response, for more useful display, by:
clipping off the tail, after 99.8% of the total power has been captured (Using 99.9% was causing problems; I don’t know why.), and
setting the “front porch” length equal to 20% of the total length.
Inputs:
g impulse response
min_len (optional) minimum length of returned vector
max_len (optional) maximum length of returned vector
Outputs:
g_trim trimmed impulse response
start_ix index of first returned sample
-
pybert.pybert_util.
import_channel
(filename, sample_per, padded=False, windowed=False)[source]¶ Read in a channel file.
- Parameters
filename (str) – Name of file from which to import channel description.
sample_per (float) – Sample period of signal vector (s).
padded (Bool) – (Optional) Zero pad s4p data, such that fmax >= 1/(2*sample_per)? (Default = False)
windowed (Bool) – (Optional) Window s4p data, before converting to time domain? (Default = False)
- Returns
Imported channel impulse, or step, response.
- Return type
[float]
-
pybert.pybert_util.
interp_time
(ts, xs, sample_per)[source]¶ Resample time domain data, using linear interpolation.
- Parameters
ts ([float]) – Original time values.
xs ([float]) – Original signal values.
sample_per (float) – System sample period.
- Returns
Resampled waveform.
- Return type
[float]
-
pybert.pybert_util.
import_time
(filename, sample_per)[source]¶ Read in a time domain waveform file, resampling as appropriate, via linear interpolation.
- Parameters
filename (str) – Name of waveform file to read in.
sample_per (float) – New sample interval
- Returns
Resampled waveform.
- Return type
[float]
-
pybert.pybert_util.
sdd_21
(ntwk)[source]¶ Given a 4-port single-ended network, return its differential throughput.
- Parameters
ntwk (skrf.Network) – 4-port single ended network.
- Returns
Sdd[2,1].
- Return type
[float]
-
pybert.pybert_util.
import_freq
(filename, sample_per, padded=False, windowed=False, f_step=10000000.0)[source]¶ Read in a single ended 4-port Touchstone file, and extract the differential throughput step response, resampling as appropriate, via linear interpolation.
- Parameters
filename (str) – Name of Touchstone file to read in.
sample_per (float) – New sample interval
padded (Bool) – (Optional) Zero pad s4p data, such that fmax >= 1/(2*sample_per)? (Default = False)
windowed (Bool) – (Optional) Window s4p data, before converting to time domain? (Default = False)
- Returns
Resampled step response waveform.
- Return type
[float]
-
pybert.pybert_util.
lfsr_bits
(taps, seed)[source]¶ Given a set of tap indices and a seed, generate a PRBS.
- Parameters
taps ([int]) – The set of fed back taps. (Largest determines order of generator.)
seed (int) – The initial value of the shift register.
- Returns
- A PRBS generator object with a next() method, for retrieving
the next bit in the sequence.
- Return type
generator
-
pybert.pybert_util.
pulse_center
(p, nspui)[source]¶ Determines the center of the pulse response, using the “Hula Hoop” algorithm (See SiSoft/Tellian’s DesignCon 2016 paper.)
- Parameters
p ([Float]) – The single bit pulse response.
nspui (Int) – The number of vector elements per unit interval.
- Returns
- The estimated index at which the clock will
sample the main lobe, and the vertical threshold at which the main lobe is UI wide.
- Return type
(Int, float)
pybert_plot - Plot definitions for the PyBERT GUI.¶
Plot definitions for PyBERT class.
Original author: David Banas<EMAIL_ADDRESS>Original date: February 21, 2015 (Copied from pybert.py, as part of a major code cleanup.)
Copyright (c) 2015 David Banas; all rights reserved World wide.
pybert_help - Contents of the Help tab of the PyBERT GUI.¶
User instructions for PyBERT class.
Original author: David Banas<EMAIL_ADDRESS>Original date: April 15, 2015 (Copied from pybert.py.)
Copyright (c) 2015 David Banas; all rights reserved World wide.
pybert_cfg - Data structure for saving PyBERT configuration.¶
Simulation configuration data encapsulation, for PyBERT.
Original Author: David Banas<EMAIL_ADDRESS>Original Date: 5 May 2017
This Python script provides a data structure for encapsulating the simulation configuration data of a PyBERT instance. It was first created, as a way to facilitate easier pickling, so that a particular configuration could be saved and later restored.
Copyright (c) 2017 by David Banas; All rights reserved World wide.
pybert_data - Data structure for saving PyBERT results.¶
Simulation results data encapsulation, for PyBERT.
Original Author: David Banas<EMAIL_ADDRESS>Original Date: 9 May 2017
This Python script provides a data structure for encapsulating the simulation results data of a PyBERT instance. It was first created, as a way to facilitate easier pickling, so that a particular result could be saved and later restored, as a reference waveform.
Copyright (c) 2017 by David Banas; All rights reserved World wide.
dfe - DFE behavioral model.¶
Behavioral model of a decision feedback equalizer (DFE).
Original Author: David Banas<EMAIL_ADDRESS>Original Date: 17 June 2014
This Python script provides a behavioral model of a decision feedback equalizer (DFE). The class defined, here, is intended for integration into the larger PyBERT framework.
Copyright (c) 2014 by David Banas; All rights reserved World wide.
-
class
pybert.dfe.
DFE
(n_taps, gain, delta_t, alpha, ui, n_spb, decision_scaler, mod_type=0, bandwidth=100000000000.0, n_ave=10, n_lock_ave=500, rel_lock_tol=0.01, lock_sustain=500, ideal=True)[source]¶ Behavioral model of a decision feedback equalizer (DFE).
-
decide
(x)[source]¶ Make the bit decisions, according to modulation type.
- Parameters
x (float) – The signal value, at the decision time.
- Returns
The members of the returned tuple are:
- decision:
One of:
{-1, 1} (NRZ)
{-1, 0, +1} (Duo-binary)
{-1, -1/3, +1/3, +1} (PAM-4)
according to what the ideal signal level should have been. (‘decision_scaler’ normalized)
bits: The list of bits recovered.
- Return type
tuple(float, [int])
- Raises
RuntimeError – If the requested modulation type is unknown.
-
run
(sample_times, signal)[source]¶ Run the DFE on the input signal.
- Parameters
sample_times ([float]) – Vector of time values at wich corresponding signal values were sampled.
signal ([float]) – Vector of sampled signal values.
- Returns
The members of the returned tuple, in order, are:
- res([float]):
Samples of the summing node output, taken at the times given in sample_times.
- tap_weights([[float]]):
List of list of tap weights showing how the DFE adapted over time.
- ui_ests([float]):
List of unit interval estimates, showing how the CDR adapted.
- clocks([int]):
List of mostly zeros with ones at the recovered clocking instants. Useful for overlaying the clock times on signal waveforms, in plots.
- lockeds([bool]):
List of Booleans indicating state of CDR lock.
- clock_times([float]):
List of clocking instants, as recovered by the CDR.
- bits([int]):
List of recovered bits.
- Return type
tuple(([float], [[float]], [float], [int], [bool], [float], [int]))
- Raises
RuntimeError – If the requested modulation type is unknown.
-
step
(decision, error, update)[source]¶ Step the DFE, according to the new decision and error inputs.
- Parameters
decision (float) – Current slicer output.
error (float) – Difference between summing node and slicer outputs.
update (bool) – If true, update tap weights.
- Returns
New backward filter output value.
- Return type
res(float)
-
cdr - CDR behavioral model.¶
Behavioral model of a “bang-bang” clock data recovery (CDR) unit.
Original Author: David Banas<EMAIL_ADDRESS>Original Date: 17 June 2014
This Python script provides a behavioral model of a “bang-bang” clock data recovery (CDR) unit. The class defined, here, is intended for integration into the larger PyBERT framework.
Copyright (c) 2019 by David Banas; All rights reserved World wide.
-
class
pybert.cdr.
CDR
(delta_t: float, alpha: float, ui: float, n_lock_ave: int = 500, rel_lock_tol: float = 0.01, lock_sustain: int = 500)[source]¶ A class providing behavioral modeling of a ‘bang- bang’ clock data recovery (CDR) unit.
-
adapt
(samples: Sequence[float]) → Tuple[float, bool][source]¶ Adapt period/phase, according to 3 samples.
Should be called, when the clock has just struck.
- Synopsis:
(ui, locked) = adapt(samples)
- Parameters
samples –
A list of 3 samples of the input waveform, as follows:
at the last clock time
at the last unit interval boundary time
at the current clock time
- Returns
- The new unit interval estimate, in seconds, and
a flag indicating ‘locked’ status.
- Return type
(float, bool)
-
property
locked
¶ The current locked state.
-
property
ui
¶ The current unit interval estimate.
-


500 Internal Server Error
The server was unable to answer just now.
You may want to send the request again a bit later.


+++ title = "Andahuaylas" lat = -13.670000 lon = -73.400000 +++
Andahuaylas is a small Andean town, situated deep in the mountains between Ayacucho and Cusco. I only stopped here for about half an hour, as it was the midpoint of my 24-hour Ayacucho-to-Cusco bus trip. Very scenic area — the town is in a massive valley, with towering mountains all around — but not much to do here, and whatever you can do here, I didn't stay long enough to see it.


Creatures
The world is full of dangerous creatures. Some are mystical beasts in hidden realms. Others are sentient and mischievous. Others still are more mysterious than that. Here are some example creatures that may exist in the world presented to you by your GM.


Toggle navigation
HeartAid.
Toggle navigation
Heart Disease
Data Analysis
Model Building
Predict
Log out
Predict
Fill the form to receive a prediction
based on the model
Age
Sex
Male
Female
Chest Pain Type
Typical Angina
Atypical Angina
Non-anginal Pain
None
Resting Blood Pressure
Serum Cholestoral
Fasting Blood Sugar
1
0
Resting Electrocardiographic
0
1
2
Maximum Heart Rate
Exercise Induced Angina
1
0
Oldpeak
Slope
0
1
2
Ca
Thal
0
1
2
3


JavaScript is a cross-platform, object-oriented scripting language. It is a small and lightweight language. Inside a host environment (for example, a web browser), JavaScript can be connected to the objects of its environment to provide programmatic control over them.
JavaScript contains a standard library of objects, such as Array, Date, and Math, and a core set of language elements such as operators, control structures, and statements. Core JavaScript can be extended for a variety of purposes by supplementing it with additional objects; for example:
Client-side JavaScript extends the core language by supplying objects to control a browser and its Document Object Model (DOM). For example, client-side extensions allow an application to place elements on an HTML form and respond to user events such as mouse clicks, form input, and page navigation.
Server-side JavaScript extends the core language by supplying objects relevant to running JavaScript on a server. For example, server-side extensions allow an application to communicate with a database, provide continuity of information from one invocation to another of the application, or perform file manipulations on a server.
What You should Already Know
This guide assumes you have the following basic background:
A general understanding of the Internet and the World Wide Web (WWW)
Good working knowledge of HyperText Markup Language (HTML).
Some programming experience. If you are new to programming, try one of the tutorials linked on the main page about JavaScript.
Java Script and Java
JavaScript and Java are similar in some ways but fundamentally different in some others. The JavaScript language resembles Java but does not have Java's static typing and strong type checking. JavaScript follows most Java expression syntax, naming conventions and basic control-flow constructs which was the reason why it was renamed from LiveScript to JavaScript.
In contrast to Java's compile-time system of classes built by declarations, JavaScript supports a runtime system based on a small number of data types representing numeric, Boolean, and string values. JavaScript has a prototype-based object model instead of the more common class-based object model. The prototype-based model provides dynamic inheritance; that is, what is inherited can vary for individual objects. JavaScript also supports functions without any special declarative requirements. Functions can be properties of objects, executing as loosely typed methods.
JavaScript is a very free-form language compared to Java. You do not have to declare all variables, classes, and methods. You do not have to be concerned with whether methods are public, private, or protected, and you do not have to implement interfaces. Variables, parameters, and function return types are not explicitly typed
Variable Scope
When you declare a variable outside of any function, it is called a global variable, because it is available to any other code in the current document. When you declare a variable within a function, it is called a local variable, because it is available only within that function.
JavaScript before ECMAScript 2015 does not have block statement scope; rather, a variable declared within a block is local to the function (or global scope) that the block resides within. For example the following code will log 5, because the scope of x is the function (or global context) within which x is declared, not the block, which in this case is an if statement.
if (true) { var x = 5; } console.log(x); // 5
This behavior changes, when using the let declaration introduced in ECMAScript 2015.
if (true) { let y = 5; } console.log(y); // ReferenceError: y is not
defined
Global Variables
Global variables are in fact properties of the global object. In web pages the global object is window, so you can set and access global variables using the window.variable syntax.
Consequently, you can access global variables declared in one window or frame from another window or frame by specifying the window or frame name. For example, if a variable called phoneNumber is declared in a document, you can refer to this variable from an iframe as parent.phoneNumber.


public class VirtualPlayerView extends java.lang.Object implements PlayerView, PlayerListener
| Constructor and Description |
|---|
VirtualPlayerView(VirtualGameView gameView,
Player player) |
| Modifier and Type | Method and Description |
|---|---|
void |
addAmmoSet(int yellowAmount,
int redAmount,
int blueAmount)
Notifies that the player associated to this view received the given amounts of ammos.
|
void |
addPowerUpCard(int cardID)
Notifies that the player associated to this view acquired a new power up card.
|
void |
addWeaponCard(int cardID)
Notifies that the player associated to thie view acquired a new weapon card.
|
void |
playerDidDiscardAmmos(Player player,
AmmoSet ammos)
Notify when a player discards some ammos
|
void |
playerDidDiscardPowerUpCard(Player player,
PowerUpCard powerUpCard)
Notify when a player discards a powerup card
|
void |
playerDidDiscardWeaponCard(Player player,
WeaponCard weaponCard)
Notify when a player discards a weapon card
|
void |
playerDidInit(PlayerData data)
Notify when a player is initialized by Game.
|
void |
playerDidReceiveAmmos(Player player,
AmmoSet ammos)
Notify when a player receives some ammos
|
void |
playerDidReceivePowerUpCard(Player player,
PowerUpCard powerUpCard)
Notify when a player receives a powerup card
|
void |
playerDidReceiveWeaponCard(Player player,
WeaponCard weaponCard)
Notify when a player receives a weapon card
|
void |
playerDidReloadWeaponCard(Player player,
WeaponCard weaponCard)
Notify when a player reloads a weapon
|
void |
playerDidUnloadWeaponCard(Player player,
WeaponCard weaponCard)
Notify when a player unloads (discharges) a weapon
|
void |
playerDidUpdateScore(Player player,
int newScore)
Notify when a player's score is updated
|
void |
reloadWeaponCard(int cardID)
Notifies that the player associated to this view reloaded the given weapon card.
|
void |
removeAmmoSet(int yellowAmount,
int redAmount,
int blueAmount)
Notifies that the player associated to this view lost the given amounts of ammos.
|
void |
removePowerUpCard(int cardID)
Notifies that the player associated to this view discarded the given power up card.
|
void |
removeWeaponCard(int cardID)
Notifies that the player associated to thie view discarded the given weapon card.
|
void |
setName(java.lang.String name)
Notifies the name of the player associated to the view.
|
void |
setPlayerData(PlayerData data)
Restores the view to the given data sent by the model.
|
void |
setScore(int score)
Notifies an update of the score of the player associated to this view.
|
void |
unloadWeaponCard(int cardID)
Notifies that the player associated to this view used the given weapon card.
|
public VirtualPlayerView(VirtualGameView gameView, Player player)
public void setPlayerData(PlayerData data)
PlayerView
setPlayerData
in interface PlayerView
public void setName(java.lang.String name)
PlayerView
setName
in interface PlayerView
public void setScore(int score)
PlayerView
setScore
in interface PlayerView
public void addPowerUpCard(int cardID)
PlayerView
addPowerUpCard
in interface PlayerView
cardID
- The ID of the power up card, according to the loaded deck, or a negative number
if the power up card is hidden.public void removePowerUpCard(int cardID)
PlayerView
removePowerUpCard
in interface PlayerView
cardID
- The ID of the power up card, according to the loaded deck, or a negative number
if the power up card is hidden.public void addWeaponCard(int cardID)
PlayerView
addWeaponCard
in interface PlayerView
cardID
- The ID of the weapon card, according to the loaded deck.public void removeWeaponCard(int cardID)
PlayerView
removeWeaponCard
in interface PlayerView
cardID
- The ID of the weapon card, according to the loaded deck.public void addAmmoSet(int yellowAmount, int redAmount, int blueAmount)
PlayerView
addAmmoSet
in interface PlayerView
public void removeAmmoSet(int yellowAmount, int redAmount, int blueAmount)
PlayerView
removeAmmoSet
in interface PlayerView
public void reloadWeaponCard(int cardID)
PlayerView
reloadWeaponCard
in interface PlayerView
public void unloadWeaponCard(int cardID)
PlayerView
unloadWeaponCard
in interface PlayerView
public void playerDidInit(PlayerData data)
PlayerListener
playerDidInit
in interface PlayerListener
data
- initial state of the player.public void playerDidReceivePowerUpCard(Player player, PowerUpCard powerUpCard)
PlayerListener
playerDidReceivePowerUpCard
in interface PlayerListener
player
- receiving the cardpowerUpCard
- card receivedpublic void playerDidDiscardPowerUpCard(Player player, PowerUpCard powerUpCard)
PlayerListener
playerDidDiscardPowerUpCard
in interface PlayerListener
player
- discarding a poerup cardpowerUpCard
- discarded powerup cardpublic void playerDidReceiveWeaponCard(Player player, WeaponCard weaponCard)
PlayerListener
playerDidReceiveWeaponCard
in interface PlayerListener
player
- receiving a weapon cardweaponCard
- received cardpublic void playerDidDiscardWeaponCard(Player player, WeaponCard weaponCard)
PlayerListener
playerDidDiscardWeaponCard
in interface PlayerListener
player
- discarding a weapon cardweaponCard
- discarded cardpublic void playerDidUpdateScore(Player player, int newScore)
PlayerListener
playerDidUpdateScore
in interface PlayerListener
player
- whose score has changednewScore
- new score of the given playerpublic void playerDidReceiveAmmos(Player player, AmmoSet ammos)
PlayerListener
playerDidReceiveAmmos
in interface PlayerListener
player
- receiving ammosammos
- receivedpublic void playerDidDiscardAmmos(Player player, AmmoSet ammos)
PlayerListener
playerDidDiscardAmmos
in interface PlayerListener
player
- discarding ammosammos
- discardedpublic void playerDidUnloadWeaponCard(Player player, WeaponCard weaponCard)
PlayerListener
playerDidUnloadWeaponCard
in interface PlayerListener
player
- discharging a weaponweaponCard
- dischargedpublic void playerDidReloadWeaponCard(Player player, WeaponCard weaponCard)
PlayerListener
playerDidReloadWeaponCard
in interface PlayerListener
player
- reloading a weaponweaponCard
- reloaded card


ObjectStorageService
public class ObjectStorageService: Service
Contains the configuration values for an Object Storage service instance
-
Undocumented
Declaration
Swift
public class ObjectStorageService: Service
-
Undocumented
Declaration
Swift
public class ObjectStorageService: Service
-
Undocumented
Declaration
Swift
public class ObjectStorageService: Service
-
Undocumented
Declaration
Swift
public class ObjectStorageService: Service
-
Undocumented
Declaration
Swift
public class ObjectStorageService: Service
-
Undocumented
Declaration
Swift
public class ObjectStorageService: Service
-
Undocumented
Declaration
Swift
public class ObjectStorageService: Service
-
Undocumented
Declaration
Swift
public class ObjectStorageService: Service
-
Undocumented
Declaration
Swift
public class ObjectStorageService: Service
-
Undocumented
Declaration
Swift
public class ObjectStorageService: Service


@Target(value={METHOD,ANNOTATION_TYPE}) @Retention(value=RUNTIME) @Documented public @interface Gateway
GatewayProxyFactoryBean
where the annotation attributes can override the default channel settings.
A method annotated with @Gateway may accept a single non-annotated
parameter of type Message
or of the intended Message payload type. Method parameters may be mapped
to individual Message header values by using the
@Header
parameter annotation. Alternatively, to pass the entire Message headers
map, a Map-typed parameter may be annotated with
Headers
.
Return values from the annotated method may be of any type. If the
declared return value is not a Message, the reply Message's payload will be
returned and any type conversion as supported by Spring's
SimpleTypeConverter
will be applied to
the return value if necessary.
Note: unlike @Publisher, this annotation is for exposing a Messaging Endpoint based on a Proxy for the marked interface method. The method invocation causes messaging interaction using an AOP Advice. Method parameters become the part of sent message (payload, headers). The method return value is the result (payload) of the messaging flow invoked by the Proxy.
MessagingGateway
| Modifier and Type | Optional Element and Description |
|---|---|
GatewayHeader[] |
headers
Specify additional headers that will be added to the request message.
|
String |
payloadExpression
Specify a SpEL expression to determine the payload of the request message.
|
String |
replyChannel
Specify the channel from which reply messages will be received; overrides the
encompassing gateway's default reply channel.
|
long |
replyTimeout
Specify the time (ms) that the thread sending the request will wait for a reply.
|
String |
replyTimeoutExpression
Specify a SpEL Expression to determine the the time (ms) that the thread sending
the request will wait for a reply.
|
String |
requestChannel
Specify the channel to which messages will be sent; overrides the encompassing
gateway's default request channel.
|
long |
requestTimeout
Specify the timeout (ms) when sending to the request channel - only applies if the
send might block (such as a bounded
QueueChannel that is currently full. |
String |
requestTimeoutExpression
Specify a SpEL Expression to determine the timeout (ms) when sending to the request
channel - only applies if the send might block (such as a bounded
QueueChannel that is currently full. |
public abstract String requestChannel
public abstract String replyChannel
public abstract long requestTimeout
QueueChannel
that is currently full.
Overrides the encompassing gateway's default request timeout.requestTimeoutExpression()
public abstract String requestTimeoutExpression
QueueChannel
that is currently full. Overrides the encompassing gateway's
default request timeout. Overrides requestTimeout()
.public abstract long replyTimeout
replyTimeoutExpression()
public abstract String replyTimeoutExpression
replyTimeout()
.public abstract String payloadExpression
public abstract GatewayHeader[] headers


Returns information about an item in a PivotTable report.
Syntax
GET.PIVOT.ITEM(type_num, pivot_item_name, pivot_field_name, pivot_table_name)
Type_num is a value from 1 to 9 the represents the type of information you want about an item in a PivotTable report.
| Type_num | Information |
| 1 | Returns the position of the item in its field. Returns #N/A if pivot_field_name is a data field. Returns #N/A! if the item is hidden. |
| 2 | Returns the reference to all the cells in the PivotTable header currently containing pivot_item_name. This reference is returned as text. If pivot_item_name is currently not showing in the PivotTable report, #N/A! is returned. |
| 3 | Returns the reference to all the data in the PivotTable report which is qualified by pivot_item_name. This reference is returned as text. If pivot_item_name is currently not showing in the PivotTable report, #N/A! is returned. |
| 4 | Returns an array of text constants representing the children of pivot_item_name if pivot_item_name is a parent. Otherwise the function returns #N/A!. |
| 5 | Returns a text constant representing the parent of pivot_item_name, if pivot_item_name exists as part of a group. Otherwise the function returns #N/A!. |
| 6 | Returns TRUE if pivot_item_name is a member of a group which is currently expanded to show detail. Returns FALSE if pivot_item_name is a member of a group currently collapsed to hide detail. If pivot_item_name is not a member of a group, the function returns #N/A!. |
| 7 | Returns TRUE if pivot_item_name is expanded to show detail. Returns FALSE if pivot_item_name is collapsed to hide detail. |
| 8 | Returns TRUE if the item pivot_item_name is currently visible, FALSE if it is hidden. |
| 9 | Returns the name of the item as it appeared in the original at a source. This will differ from the current item name only if the user changes the name of the item after creating the PivotTable report. |
Pivot_item_name is the name of the item that you want information about. If there is no item named pivot_item_name in the PivotTable report, returns #VALUE!.
Pivot_field_name is the name of the field that you want information about. If there is no field named pivot_field_name in the PivotTable report, returns #VALUE!.
Pivot_table_name is the name of a PivotTable report containing the field that you want information about. If omitted, uses the PivotTable report containing the active cell. If the active cell is not in a PivotTable report, the #VALUE! error value is returned.
Related Functions
GET.PIVOT.FIELD Returns information about an item in a PivotTable report.
GET.PIVOT.TABLE Returns information about a PivotTable report.
Return to index


Routing network traffic based on firewall logs using Machine Learning
Source Port:
Destination Port:
NAT Source Port:
NAT Destination Port:
Bytes:
Bytes Sent:
Bytes Received:
Packets:
Elapsed Time (sec):
pkts_sent:
pkts_received:
Submit


Command Execution
Executing commands with Vshadow is dependent upon a ‘successful’ interaction with a shadow copy operation (e.g. creating a snapshot, removing a snapshot, doing something with a snapshot, etc.). Vshadow.exe supports the -exec parameter, which can be used to execute a binary (.exe) or a script (.bat/.cmd). The -exec parameter does not support command arguments, so payload execution needs to be wrapped up within the context of these limitations.
Before proceeding, let’s consider a few other requirements for command execution.
Firstly, we need to have privileges on the machine (e.g. administrator) as working with volume snapshots (and invoking the Volume Shadow Service) is deemed a sensitive operation.
Secondly, we need to get the Vshadow executable onto the target machine. If the Windows SDK is already installed, then all we have to do is locate the path to the binary on disk. Otherwise, we’ll have to transfer it over.
Lastly, we need to ensure that our payload is wrapped up as discussed previously. For our command execution example, we will simply use notepad.exe as our payload.
Invoking a payload with vshadow.exe is not exactly the stealthiest method, but we can operate the tool in such a way to minimize our footprint. The basic structure of our command is as follows:
vshadow.exe -nw -exec=<\path\to\exe> <system drive>
Specifying -nw allows us to create a shadow copy without invoking shadow copy writers. Effectively, this is a non-persistent shadow copy, which will not leave “physical” disk evidence (*Please note that this does not necessarily prevent the detection of shadow copy creation as we are still going through the simulated process). Now, let’s run the following command:
vshadow.exe -nw -exec=c:\windows\system32\notepad.exe c:
Successful execution of Vshadow in this context will create a ‘faux’ shadow copy set, then launch the payload (notepad.exe) as specified by the -exec parameter. A few interesting things are happening here that may be useful for defensive and forensics folks to know…
Vshadow.exe will not finish executing until the child process is finished executing.
The payload (notepad.exe) is a child process of vshadow.exe
Successful execution of Vshadow will kick off the Volume Shadow Service (VSS) as indicated by System Event ID 7036 and invocation of the VSSVC.exe process.


Step 1
This is step one
Step 2
This is step two
Step 3
This is step three
Step 5
This is step five
Step 1
Step 2
Step 3
Step 4
Step 5


Please enter your username or email address. You will receive a link to create a new password via email.
Username or Email Address
Log in | Register
← Back to Groci – Organic Food and Grocery Theme


- Pages generated on server side
- Generally not stateless
- Need to reflect back UI state to the server
- Coupling between UI and Server
- Biggest requests
Works fine, but not so easy to make complex UI, because slower,
less ergonomic and so less user friendly


Great car offers, dead simple
Find your next car from the comfort of home, without traipsing around dealers nor haggling on price. Just tell us the car you want and get great offers from pre-vetted sellers.
Let Auto Mart help you choose your next car
In 3 easy steps, you can have the car of your dreams
Little or large? Sleek or simple? Powerful or practical? Choose the perfect car for you just the way you want it.
View offers from approved local and national dealers and compare price, location and dealer rating – no hidden costs.
Simply contact your preferred dealer to book a test drive - if they are amenable. You can discuss all the details, then buy direct with a full AutoMart warranty.


Hey there! Thanks for checking out my blog! Hope this gave you some great insight on the myriad of llama cultures around the country
and maybe will even inspire you to do your own traveling (:
Feel free to check out my site www.allysorge.com for more about me unrelated to my travels.


Spring framework provides a comprehensive and extensible authentication and authorization support. Latest enhancements in Spring 5.x have made it simple to apply security standards such as OAuth2 to secure applications. In this blog I will demonstrate leveraging second-generation of OAuth2 support in Springframework security in a distributed and reactive-based microservices application.
Architecture
A Spring-based simulation of a flight reservation web application is created for this blog to illustrate applying the latest Springframework 5.x security features to secure a distributed microservices application. The architecture of the demonstrating application consists of a front-end web application and a couple of backend microservices. All modules of the application are implemented using Spring Boot to take advantage of the auto-configuration features to setup the application. All Services in the application are implemented with reactive WebFlux support provided by Springframework.
As illustrated in the diagram below, the system consists of:
-
Front-end Web application implemented using Thymeleaf. The application allows a user to search for a flight from an origin to a destination within certain dates, select and book the itinerary. The module is named as agency-web.
- A back-end service to retrieve available itinerary flights, named as flights-service.
- A back-end service to perform reservations and book the itinerary, named as reservations-service.
Additionally, the application uses common Spring Cloud services such as:
- A registration and discovery service using Spring Cloud Eureka implementation to help services to register and discover each other.
- A Spring Cloud Gateway in front of the flights and reservations backend services.
Running the Application
Follow the steps below to run the application:
- clone the application from github
$ git clone https://github.com/Haybu/RA-OAuth2-Gen2.git
- Build the application from the project home directory
$ mvn clean install
- Launch the UAA authorization server.
$ ./uaa-server/gradlew -b ./uaa-server/build.gradle uaa
- Bring up all services by running the shell script startup.sh
$ ./startup.sh
Application Flow
After bringing all modules up, access the web application at http://localhost:8080. You will be redirected to the OAuth2 authorization server (UAA) to authenticate and authorize to the application. Once successfully logged in, search for a trip itinerary by entering: origin as AUS, destination as IAH, departure date as 5/5/2018 and return date as 5/22/2018.
The application will display a list of flights, select an outbound flight, an inbound flight, review select seletected flights and click on “book” button. The application will display a reservation confirmation number for each flight.
As illustrated in the sequence diagram below, the client application utilizes a backend “flights service” to search for available flights per a user search request. Additionally, a “reservations” backend service is also helping a client to book the selected flights. The client application and both backend services are implemented using Spring Boot. They all leverage Spring Cloud Eureka for services registrations and discoveries. The front-end client application talks to the backend services via a Spring Cloud Gateway.
Services Registration and discovery
Client application, the two backend API services and the gateway application
all register themselves automatically with a Spring Cloud Eureka server when they
spin up. The client application uses a “WebClient” bean to interact with any of the backend
services. The “WebClient” beans are configured with a “LoadBalancerExchangeFilterFunction”
filter to help with balancing out between the discovered target services’ instances.
For example, a client application defines a load-balanced “WebClient” bean as listed below and uses that to interact with underneath discovered gateway from a Eureka service.
@Bean
WebClient webClient(LoadBalancerExchangeFilterFunction eff,
ReactiveClientRegistrationRepository repo1,
ServerOAuth2AuthorizedClientRepository repo2)
{
ServerOAuth2AuthorizedClientExchangeFilterFunction oauth2 =
new ServerOAuth2AuthorizedClientExchangeFilterFunction(repo1, repo2);
return WebClient.builder().filter(eff).filter(oauth2).build();
}
Spring Cloud Gateway
The web client application communicates with the two backend micorservices via a Spring Cloud Gateway. The Gateway is configured to route based on the target’s path to each proxied backend service. And As shown below, a “RewritePath” filter is defined to observe the context path to each target service.
spring:
cloud:
gateway:
routes:
- id: flights_service_route
uri: lb://flights-service
predicates:
- Path=/api/flights/**
filters:
- RewritePath= /api/flights/(?<segment>.*),/flights/$\{segment}
- id: reservations_service_route
uri: lb://reservations-service
predicates:
- Path=/api/reservations/**
filters:
- RewritePath= /api/reservations/(?<segment>.*),/reservations/$\{segment}
Security
In this architecture we need to apply Spring security to the client application and the two backend microservices. New security enhancement in spring 5.x paves the way to seamlessly secure applications using OAuth2 standards.
Web Application - OAuth2 Client
You can take advantage of auto-configuring clients with Spring Security if you have “spring-security-oauth2-client” dependency in your classpath. It is even getting simpler to register as many clients as you desire using properties with “spring.security.oauth2.client” prefix, and define your provider’s properties with “spring.security.oauth2.provider” prefix.
For instance, in this sample, after the web client application is registered with one of the OAuth2 / OpenID Connect providers (like UAA), you can configure the web application with properties to register a client using the a client-id and client-secret. Also you can define the selected client’s provider with information such as the authorization URI, token URI, user-info URI and JWK set URI. With those providers who support OpenID Connect discovery, the configuration could be further simplified by specifying the issuer URI (with “spring.security.oauth2.client.provider. oidc-provider.issuer-uri” prefix).
The configuration listing above shows an example of properties used to register a client and a provider.
spring:
security:
oauth2:
client:
registration:
login-client:
client-id: login-client
client-secret: secret
client-authentication-method: basic
scope: openid,profile,email
authorization-grant-type: authorization_code
client-name: Login Client
redirect-uri-template: "{baseUrl}/login/oauth2/code/{registrationId}"
provider: uaa
provider:
uaa:
authorization-uri: http://localhost:8099/uaa/oauth/authorize
token-uri: http://localhost:8099/uaa/oauth/token
user-info-uri: http://localhost:8099/uaa/userinfo
user-name-attribute: sub
jwk-set-uri: http://localhost:8099/uaa/token_keys
Reservations Service and Flights Service as Resource Servers
You can designate and configure a resource server in Spring Security 5.x by having “spring-security-oauth2-resource-server” in your classpath. Spring Boot can set up an OAuth2 Resource Server as long as JWK Set URI or OIDC Issuer URI is specified.
For example, the flight service acts as a resource server and is configured using the properties below. With this setup the client application can communicate securely with the backend flights service.
spring:
security:
oauth2:
resourceserver:
jwt:
jwk-set-uri: http://localhost:8099/uaa/token_keys
Spring Cloud Gateway
The Spring Cloud Gateway in this architecture acts as an API gateway service to the frontend web application. It routes traffic to targeted backend microservices. Spring Cloud Gateway passes through the Authentication token it receives from the client application as an “Authorization” Bearer header.
Conclusion
The Spring security team at Pivotal made significant improvements to secure client and resource server applications with Spring Security 5.x. One can easily secure applications using OAuth2 standards with so minimum fuss. You can get it all configured by specifying the appropriate security dependencies and configuration properties to configure a client, resource server or optionally a provider.
Resources
- Sample Demo application Code in Github
- Spring Security Documentation


Name |
{$pet.pet_name} |
|---|---|
About |
|
Feed |
|
Breed |
{$pet.breed_name} |
Birth |
{$pet.pet_birth} |
The Pet gets on well with: |
|
| Garden Children Other Pets | |
The Pet would like: |
|
| Exercise Company | |
The Pet want a helper at: |
|
| Day Evening Weekend Holiday | |
Notes |
{$pet.pet_notes} |
Title |
{$begInfo.beg.beg_title} |
|---|---|
Completion |
|
Email |
{$begInfo.beg.beg_email} |
Phone |
{$begInfo.beg.beg_phone} |
Location |
{$begInfo.beg.beg_location} |
Notes |
{$begInfo.beg.beg_notes} |


[§554C-11] Application to existing trusts. This chapter applies to trusts existing on and created after April 14, 1997. As applied to trusts existing on April 14, 1997, this chapter governs only decisions or actions occurring after that date. [L 1997, c 26, pt of §1]
Revision Note
"April 14, 1997" substituted for "its effective date".


If you have enabled UEFI Boot, a few EFI-related files need to be copied to a new location in the ISO. If those files are missing from the original ISO, you may receive this error. If this error does occur, Slips7ream will continue with the integration process without enabling UEFI.
If "bootmgfw.efi" can not be found, Slips7ream will prompt you with an EFI File Not Found error dialog. The error will not interfere with the Slipstream process, but it will prevent the UEFI Boot feature from being enabled.
If the "\EFI\MICROSOFT\BOOT\" folder can not be found, Slips7ream will prompt you with an EFI Folder Not Found error dialog. The error will not interfere with the Slipstream process, but it will prevent the UEFI Boot feature from being enabled.


4.4. Home Application¶
This simple application handles logins and logouts as well as new user registration. This application should probably be rolled in with webapp for the sake of portability.
4.4.1. Subpackages¶
4.4.2. Submodules¶
4.4.3. home.admin module¶
4.4.4. home.models module¶
4.4.5. home.serializers module¶
4.4.6. home.tests module¶
4.4.7. home.views module¶
-
class
home.views.
UserViewSet
(**kwargs)¶ Bases:
rest_framework.viewsets.ModelViewSet
-
queryset
¶
-
serializer_class
¶ alias of
UserSerializer
-
-
home.views.
account
(request)¶ A view that returns the account page of the requesting user. This is barebones, but could be expanded to provide the user with information on their own account. This is not the settings page.
Templates:
base/account.html
-
home.views.
index
(request)¶
-
home.views.
register
(request)¶ A view that renders the register page for new users. This can only be access by users that are not currently signed in.
Context
form
Registration form for new usersTemplates:
base/register.html
-
home.views.
signin
(request)¶ A view that renders the sign-in page for existing users. All verification is done on the server side.
Context
form
Sign-in form for existing usersTemplates:
base/signin.html
-
home.views.
signout
(request)¶


Care home 'needs deep clean and has bad smells', says damning report
There was 'unexplained bruising' on one resident and 'heavy staining' in the bathroom
by Conor GogartyInspectors have found a family-run Brislington care home needs a “deep clean” and ordered it to address bad smells.
The Care Quality Commission (CQC) has published a report which rates Robleaze House, on Bath Road, ‘requires improvement’ following a September inspection.
The watchdog was concerned by “unexplained bruising” on one resident, as well as missing plaster in a bedroom, “heavy staining” in the bathroom and “malodours” in parts of the home.
It also revealed the inspection was prompted by a police investigation into a safeguarding incident.
“This was not substantiated but we needed to be assured people were safe,” the report reads.
The CQC found Robleaze to be in breach of six regulations, rating it ‘requires improvement’ in its safety, effectiveness, responsiveness and leadership, despite a ‘good’ level of caring.
Incidents not reported
Robleaze, which previously had an overall ‘good’ rating, cares for 10 people with a learning disability, four of whom have lived there since it opened 26 years ago.
The report says: “During the inspection we saw there had been two incidents in August 2019 where a person had kicked two other people in the home.
“Whilst these did not result in serious injury, these had not been reported to Bristol City Council's safeguarding team or to the Care Quality Commission.
“They have a legal responsibility to report these to the Care Quality Commission and the local authority's safeguarding team.
“There has also been some unexplained bruising to one person these had not been reported to safeguarding.”
'Not properly maintained'
The inspectors said parts of the home required a “deep clean” and also highlighted missing tiles in the “dated” shower room.
“Another bathroom had heavy staining on the floor, the grout and sealant needed to be replaced around the bath,” they added.
“There were cleaning schedules in place, but these had not been completed for the month of September 2019.
“One bedroom had a water mark on the roof. We were told this had occurred 18 months ago.
“This had been noted at the last inspection in April 2018. The premises were not properly maintained.”
The CQC deemed people in the home to be at risk from a resident who was “known to tip furniture”.
Despite this, there was no mention in this person's care plan about how staff should support them.
'No temperature checks'
“There were no temperature checks completed to ensure medication was stored at the correct temperature and safe for use," the report continues.
“One person had a medical condition which meant they needed supervision when bathing.
“Recommendations had been made by health and social care professionals, but these had not been incorporated into the care plan to keep them safe."
The inspectors also found there was no formal process to record staff inductions or show competence in giving medicine.
Four staff members had received no formal supervision in the previous 10 months.
The report also says: “People and their relatives spoke positively about the care and support provided by the staff and the registered manager.”
Robleaze has been approached for comment.
For the latest news in and around Bristol, check back on Bristol Live's homepage.


---
extends: minimal.j2
default_block: main
title: Research
description: Description of Past and Current Research Interests
---
Research
Current Role
I am currently a Senior Data Science Fellow and Director of Open Software
at the University of Washington eScience Institute.
In this role, I spend much of my time facilitating connections between
researchers across UW's campus, as well as teaching and advocating for
open and reproducible research practices.
Additionally, I invest time in supporting, developing, and
maintaining various open source scientific and data science packages
in the Python world.
Through all of this, I enjoy working on the statistical and computational
methodologies that are helping push forward astronomical research in the
era of ever-growing datasets.
Background
After completing my undergraduate studies in Physics at Calvin College, I
took a few years off before returning to academia. In those years I lived in
Sendai, Japan, where I taught English at a non-profit student center, then
returned to the US and spent two years as an outdoor educator with Mount
Hermon Outdoor Science School (just outside Santa Cruz, CA) and Summit
Adventure (just outside Yosemite). Those two years working and teaching
outdoors among the Redwoods, Sequoias, granite peaks, and dark skies rekindled
my interest in science in general, and Astronomy in particular. I began my
doctoral studies at the UW in 2006, finishing in 2012, after which I had two
short post-doc appointments before joining the eScience Institute in 2014.
When not working on my research, I enjoy growing food in my garden, eating
that food in large quantities, traveling, experiencing the world through
my daughter's eyes, and occasionally escaping to the mountains for long
trail-runs.
Past Projects
I started my PhD with a vague interest in cosmology, and a hope to land in an
institution with the resources to learn more. UW offered plenty of
opportunities in that area.
- Type Ia Supernovae
After beginning my graduate studies, I quickly became involved in the SDSS-II
supernova team. The project had the advantage of being very sensitive to events
in the so-called "redshift desert" between z=0.05 and z=0.4. Under the guidance
of PI Rick Kessler, we used the first-year results as a background to do the
first serious comparison of systematic effects of the two of the leading
light-curve fitters.
- Machine Learning/Open Source Software
In 2008 I began exploring a nonlinear dimensionality reduction technique
called Locally Linear Embedding (LLE). LLE has been broadly studied in various
fields relating to computer perception, and we showed that it is useful in
processing galaxy spectra. In particular, the dimensionality reduction is
sensitive to nonlinear effects that are lost by more familiar techniques such
as PCA. I ended up submitting a version of this code to the open source
scikit-learn project, and have remained involved.
I've since invested a lot of energy into other open source
Python projects in the realm of machine learning, data mining, and
visualization, and have co-authored a
textbook
on these subjects, focusing on applications to astronomy and astrophysics.
- Weak Gravitational Lensing
My PhD dissertation work was in the area of Weak Gravitational Lensing.
Working with Andy Connolly at UW, as well as Bhuvnesh Jain and
Mike Jarvis at University of Pennsylvania, I explored ways in which data
compression and noise filtration algorithms similar to PCA could be used
in generating mass maps and computing cosmological constraints from weak
lensing shear catalogs.
- Observational Probes of Scalar/Tensor Gravity Theories
In collaboration with collaborators at the University of
Pennsylvania, I've published several papers exploring small-scale effects
of modifications to General Relativity (GR) which might be behind the
accelerated expansion of the universe. To be consistent with Solar System
observations, these theories must allow any fifth-force effects to be
somehow screened within our own galaxy so that GR is recovered. These
screening mechanisms lead to some interesting dynamical and morphological
consequences in the case of isolated dwarf galaxies. We've been exploring
observations which might constrain the strength of these modifications.
- Astronomy Education: UW Planetarium
During my graduate career, I was involved in the University of
Washington Planetarium in a variety of positions. For two years, I oversaw our
K-12 outreach program, providing free planetarium shows to school groups from
the greater Seattle area. Later, I spent two years managing and coordinating the
installation of a new digital projection system in the planetarium, built upon
World Wide Telescope in collaboration with Microsoft Research (see a feature
on the project here). Through these opportunities, I had the chance to
facilitate hands-on exploration of the universe with thousands of people both
in Seattle and around the country.
- NSF Fellowship
During 2013, I was a post-doctoral fellowship through the NSF's Transformative
Computational Infrastructure program (CI-TraCS), and worked at UW jointly
between the Computer Science department's Database Group, and the Astronomy
department's survey science group. I worked primarily on ways to utilize
advances from the field of database research to enable new approaches to
data-intensive areas of Astronomy and Astrophysics.


Key BindingsOn this page you can assign key shortcuts to actions and (menu-)commands. You can do this by first clicking an action or command from the big list on the top. If this action already contains one or more keybindings, these key combinations will be displayed in the list on the left-hand side. To delete one of these bindings, you can select it and click Delete. To bind a new key combination to the action selected, you can click on the edit box and type the combination. This combination can consist of one or two key strokes. If you mistype a combination, type it again until it is correctly displayed. All this may sound confusing at first, but I suggest you just try it. If you assign a key combination consisting of two keystrokes to an action, the first of the two will be considered to be a prefix. It is therefore not possible to use this prefix as a sole key combination for another action. |
|||
|
Last updated: 05/17/98 |


import numpy as np
import gmpy2 as gm
'''
This file computes recursively the alpha, beta, gamma, and eta
coefficients from the Kasso, Tuley paper OP on SG.
The recursions are memoized (meaning they store the previously computed
values in dictionaries) for increased performance. These functions
are faster when you require specific values of the coefficients.
For large computations that use all the coefficients for multiple times,
it will be better to use the functions alpha_array, beta_array, etc.
'''
# This global variable can be used to change the recursion limit for
# better speed at high indices
j_max_rec = 1000
[docs]def zeros_gm(m, n):
'''
This function creates an m x n array of gmpy2 zeros.
It is used instead of np.zeros in places where rational
arithmetic is required.
'''
arr = np.array([[gm.mpz(0) for i in range(n)] for j in range(m)])
return arr
[docs]def eye_gm(n):
'''
This function creates an n x n identity matrix using gmpy2 ones
and zeros. It is used instead of np.eye in places where rational
arithmetic is required.
'''
arr = zeros_gm(n, n)
for i in range(n):
arr[i, i] = gm.mpz(1)
return arr
[docs]def mem(func):
'''
This is a decorator function that memoizes the recursive functions.
This function is used as a decorator in multiple places thoughout the
code files.
'''
cache = dict()
def memoized_func(*args):
if args in cache:
return cache[args]
result = func(*args)
cache[args] = result
return result
return memoized_func
[docs]def mem2(func):
'''
This is a decorator function that memoizes recursive functions that
return arrays of values from index 0 to j. If the recursion has
already been called on a higher index, this decorator will cause
the function to automatically return those precomputed values.
Example: Suppose mem2 decorates the function alpha_array(j),
which returns [alpha_0, ... , alpha_j]. Calling alpha_array(10)
will return [alpha_0, ... , alpha_10].
Calling alpha_array(5) immediately after will return
[alpha_0, ... , alpha_10] without having to compute
those values again.
'''
cache = dict()
def memoized_func2(*args):
check = False
key_sp = None
for key in cache.keys():
if args <= key:
check = True
key_sp = key
break
if check:
return cache[key_sp]
result = func(*args)
cache[args] = result
return result
return memoized_func2
# The follwing functions compute single values of alpha, beta, gamma,
# eta, and t from Calculus paper, and alpha prime from the Kasso,
# Tuley paper.
[docs]@mem
def alpha(j):
'''
Calculates alpha_j.
Args:
j: index of coefficient
Returns:
value of alpha_j
'''
# For large index j, switch to array evaluation mode
if j >= j_max_rec:
return alpha_array(j)[j]
# Otherwise, calculate directly based on (2.9) of Calculus I paper
if j == 0:
return 1
if j == 1:
return gm.mpq(1,6)
res = 0
for l in range(1, j):
res += alpha(j-l)*alpha(l)
return gm.mpq(res*4,(5**j - 5))
[docs]@mem
def beta(j):
'''
Calculates beta_j
Args:
j: index of coefficient
Returns:
value of beta_j
'''
# For large index j, switch to array evaluation mode
if j >= j_max_rec:
return beta_array(j)[j]
# Otherwise, calculate directly based on (2.11) of Calculus I paper
if j == 0:
return gm.mpq(-1,2)
res = 0
for l in range(j):
res += (3*5**(j-l) - 5**(l+1) + 6)*alpha(j-l)*beta(l)
return gm.mpq(res*2,(15*(5**j - 1)))
[docs]@mem
def gamma(j):
'''
Calculates gamma_j
Args:
j: index of coefficient
Returns:
gamma_j value
'''
# For large index j, switch to array evaluation mode
if j >= j_max_rec:
return gamma_array(j)[j]
# Otherwise, calculate directly based on (2.12) of Calculus I paper
return 3*alpha(j+1)
[docs]@mem
def eta(j):
'''
Calculates eta_j
Args:
j: index of coefficient
Returns:
value of eta_j
'''
# For large index j, switch to array evaluation mode
if j >= j_max_rec:
return eta_array(j)[j]
# Otherwise, calculate directly based on (2.37) of Calculus I paper
if j == 0:
return 0
res = gm.mpq(alpha(j)*(5**j + 1),2)
for l in range(j):
res += 2*eta(l)*beta(j-l)
return res
[docs]@mem
def tau(j):
'''
Calculates tau_j
Args:
j: index of coefficient
Returns:
value of tau_j
'''
# For large index j, switch to array evaluation mode
if j >= j_max_rec:
return tau_array(j)[j]
# Otherwise, calculate directly based on (2.37) of Calculus I paper
if j == 0:
return gm.mpq(-1, 2)
res = beta(j)
for l in range(j):
res -= 6*alpha(j+1-l)*tau(l)
return res
[docs]@mem
def ap(j):
'''
Calculates alpha'_j
Args:
j: index of coefficient
Returns:
alpha'_j value
'''
# For large index j, switch to array evaluation mode
if j >= j_max_rec:
return alpha_array(j)[j]
# Otherwise, calculate directly based on (4) of Tuley paper
if j == 0:
return gm.mpq(1,2)
return alpha(j)
# Here we calculate an array of values listed above.
[docs]@mem2
def alpha_array(max_order):
'''
Calculates the array of alpha_j up to some order
Args:
max_order: Maximum order of j to be calculated (should be >= 1)
Returns:
alpha_arr: np.array of length (max_order+1) containing the first
values of alpha up to alpha_{max_order}.
'''
alpha_arr = zeros_gm(max_order + 1, 1)
alpha_arr[0] = gm.mpz(1)
alpha_arr[1] = gm.mpq(1,6)
for j in range(2, max_order+1):
for l in range(1, j):
alpha_arr[j] = alpha_arr[j] + alpha_arr[j-l] * alpha_arr[l]
alpha_arr[j,0] = gm.mpq(alpha_arr[j,0] * 4 ,(5 ** j - 5))
return alpha_arr[:, 0]
[docs]@mem2
def beta_array(max_order):
'''
Calculates the array of beta_j up to some order
Args:
max_order: Maximum order of j to be calculated (should be >= 1)
Returns:
beta_arr: np.array of length (max_order+1) containing the first
values of beta up to beta_{max_order}.
'''
# alpha's are used in the calculation of beta, so we first calculate
# these
alpha_arr = alpha_array(max_order+2)
# initialize values of beta_arr
beta_arr = zeros_gm(max_order + 1, 1)
beta_arr[0] = gm.mpq(-1,2)
for j in range(1, max_order+1):
for l in range(j):
beta_arr[j] = beta_arr[j] + (3 * (5 ** (j-l)) -
5 ** (l + 1) + 6) * alpha_arr[j-l] * beta_arr[l]
beta_arr[j] = beta_arr[j] * gm.mpq(2 , (15 * (5 ** j - 1)))
return beta_arr[:, 0]
[docs]@mem2
def gamma_array(max_order):
'''
Calculates the array of gamma_j up to some order
Args:
max_order: Maximum order of j to be calculated (should be >= 1)
Returns:
gamma_arr: np.array of length (max_order+1) containing the first
values of gamma up to gamma_{max_order}.
'''
alpha_arr = alpha_array(max_order+2)
gamma_arr = 3 * alpha_arr
return np.array(gamma_arr[1:])
[docs]@mem2
def eta_array(max_order):
'''
Calculates the array of eta_j up to some order
Args:
max_order: Maximum order of j to be calculated (should be >= 1)
Returns:
eta_arr: np.array of length (max_order+1) containing the first
values of eta up to eta_{max_order}.
'''
eta_arr = zeros_gm(max_order + 1, 1)
eta_arr[0] = 0
alpha_arr = alpha_array(max_order)
beta_arr = beta_array(max_order)
for j in range(1, max_order + 1):
res = alpha_arr[j]*gm.mpq((5**j + 1), 2)
for l in range(j):
res += 2*eta_arr[l]*beta_arr[j-l]
eta_arr[j] = res
return eta_arr
[docs]@mem2
def tau_array(max_order):
'''
Calculates the array of tau_j up to some order (this is
originally called t in the Calculus paper)
Args:
max_order: Maximum order of j to be calculated (should be >= 1)
Returns:
tau_arr: np.array of length (max_order+1) containing the first
values of tau up to tau_{max_order}.
'''
tau_arr = zeros_gm(max_order + 1, 1)
tau_arr[0] = gm.mpq(-1, 2)
alpha_arr = alpha_array(max_order+1)
beta_arr = beta_array(max_order)
for j in range(1, max_order + 1):
res = beta_arr[j]
for l in range(j):
res -= 6*alpha_arr[j+1-l]*tau_arr[l]
tau_arr[j] = res
return tau_arr
[docs]@mem2
def ap_array(max_order):
'''
Calculates the array of alpha'_j up to some order
Args:
max_order: Maximum order of j to be calculated (should be >= 1)
Returns:
ap_arr: np.array of length (max_order+1) containing the first
values of alpha' up to alpha'_{max_order}.
'''
ap_arr = alpha_array(max_order)
ap_arr[0] = gm.mpq(1, 2)
return ap_arr


A Startup Idea Every Day #1.
Yes, you heard me.
Going into 2014, I decided I was going to read more, write more, and watch less. So for january of 2014, I'm going to give away a brilliant startup idea every day, for 31 days.
Part of the reason I decided to do this was that I keep comping up with ideas that I would really like to see set into motion, but I am already way to bogged down with my current projects. For me, this is a creative exercise that involves me pushing my ability to think of new ways we can use technology. Enough talking.
Idea #1
An e-commerce site designed for developers.
How would this work? I'm a developer, I've got quite a few websites, and I would like to be able to easily monetize traffic, but I don't want to have to claw at revenue from AdSense or Amazon or any other affiliate platform. I would like to be able to display a product on my website, and when users click on it they would be taken to a purchasing page. Once a purchase is made, I would get whatever the difference was between the price I sold the product at, and the price the owner of the product wants.
Who actually sells the product? Think of all the people who sell items on eBay, Amazon, or Etsy. They could list their product on this website, with a photo, description, etc., and than any developer who was interested in reselling it could put the product on their website at a markup that the developer determines.
How much room for growth is there with this idea? Tons. The way I've envisioned it, on one side of the site, there would be the merchants selling the products. The list as many items as they would like to sell. On the other side, there are the developers. Developers would have access to a robust API that would allow them to build an entire online store, without ever seeing merchandise, or printing a shipping label. The API could even include the ability to pay for an entire shopping cart full of items. There are a lot of possibilities with this startup idea, what are you waiting for, go do it!


Spices
Recipes
My Cart
My Account
Contact Us
Payment Form
Billing Information (required)
First Name
Last Name
Street Address
Street Address (2)
City
State
ZIP/Postal Code
Country
Phone
Credit Card (required)
Credit Card Number
Expiration Date
--Month--
January (01)
February (02)
March (03)
April (04)
May (05)
June (06)
July (07)
August (08)
September (09)
October (10)
November (11)
December (12)
--Year--
2017
2018
2019
2020
2021


Next: P-A1 Domain and range
Up: COLLABORATIVE VOCABULARY DEVELOPMENT PRACTICES
Previous: P-V4 Linked Data validation
In sec:vocab-analysis we analysed common practices that are followed by vocabulary engineers (i.e. the creation of object properties and their associated domain and range axioms).
It is important to remark that those practices are always domain dependent, but still can serve as general guidelines to be followed in the process of designing vocabularies.
Subsections
lavdim
2015-08-12


Create a custom checkout page in minutes and Increase your sales with WooLentor
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the indu stry's standard dummy text ever since the 1500s when an unknown prnter took a galley of type and scramb has been text ever since them 1500s unknown type and scramb led it to make a type specimen book.
There are many variations of passages of Lorem Ipsum available, but the majority have suffered alteration in some form, by injected humour, or randomised words which don't look even slightly believable. If you are going to use a passage of orem Ipsum, you need to be sure there isn't anything embarrassing hidden in the middle of text. All the Lorem psum generators on the Internet tend predefined chunks as necessary, making this the first true generator on the Internet. It uses dictionary of over Latin words combnes with a handful of model sentence structures.
Table of Content:
- It was popularised in the 1960s with the release of Letraset sheets containing
- Many desktop publishing packages and web page editors now use
- It was popularised in the 1960s with the release of Letraset sheets containing
- Many desktop publishing packages and web page editors now use
- It was popularised in the 1960s with the release of Letraset sheets containing
There are many variations of passages of Lorem Ipsum available, but the majority have suffered alteration in some form, by injected humour, or randomised words which don't look even slightly believable. If you are going to use a passage of orem Ipsum, you need to be sure there isn't anything embarrassing hidden in the middle of text. All the Lorem psum generators on the Internet tend predefined chunks as necessary, making this the first true generator on the Internet. It uses dictionary of over Latin words combnes with a handful of model sentence structures.
Our company fails the real world test in all kinds of ways.
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the indu stry's standard dummy text ever since the 1500s when an unknown prnter took a galley of type and scramb has been text ever since them 1500s unknown type and scramb led it to make a type specimen book.
There are many variations of passages of Lorem Ipsum available, but the majority have suffered alteration in some form, by injected humour, or randomised words which don't look even slightly believable. If you are going to use a passage of orem Ipsum, you need to be sure there isn't anything embarrassing hidden in the middle of text. All the Lorem psum generators on the Internet tend predefined chunks as necessary, making this the first true generator on the Internet. It uses dictionary of over Latin words combnes with a handful of model sentence structures.
Well, that wasn’t the only unconventional thing 37Signals did on their way up.
There are many variations of passages of Lorem Ipsum available, but the majority have suffered alteration in some form, by injected humour, or randomised words which don't look even slightly believable. If you are going to use a passage of orem Ipsum, you need to be sure there isn't anything embarrassing hidden in the middle of text. All the Lorem psum generators on the Internet tend predefined chunks as necessary, making this the first true generator on the Internet. It uses dictionary of over Latin words combnes with a handful of model sentence structures.
There are many variations of passages of Lorem Ipsum available, but the majority have suffered alteration in some form, by injected humour, or randomised words which don't look even slightly believable. If you are going to use a passage of orem Ipsum, you need to be sure there isn't anything embarrassing hidden in the middle of text. All the Lorem psum generators on the Internet tend predefined chunks as necessary, making this the first true generator on the Internet. It uses dictionary of over Latin words combnes with a handful of model sentence structures.
2,83k People Receive Our Weekly WordPress Related Newsletter.
There are many variations of passages of Lorem Ipsum available, but the majority have suffered alteration in some form, by injected humour, or randomised words which don't look even slightly believable. If you are going to use a passage of orem Ipsum, you need to be sure there isn't anything embarrassing hidden in the middle of text. All the Lorem psum generators on the Internet tend predefined chunks as necessary, making this the first true generator on the Internet. It uses dictionary of over Latin words combnes with a handful of model sentence structures.
There are many variations of passages of Lorem Ipsum available, but the majority have suffered alteration in some form, by injected humour, or randomised words which don't look even slightly believable. If you are going to use a passage of orem Ipsum, you need to be sure there isn't anything embarrassing hidden in the middle of text. All the Lorem psum generators on the Internet tend predefined chunks as necessary, making this the first true generator on the Internet. It uses dictionary of over Latin words combnes with a handful of model sentence structures.
Comments (3)
Edna Watson
There are many variations of passages of Lorem Ipsum available, but the majority have suffered alteration in some form humour, or randomised words which don't look even slightly believable. If you are going to use a passage of orem psum to be sure there isn't anything embarrassing.


Button Style In Bootstrap 4
primary
info
success
warning
danger
secondary
dark
light
Outline Button style in Bootstrap 4
primary
info
success
warning
danger
secondary
dark
light
Button size in Bootstrap 4
Large Button
Default Button
Small Button
Button Group in Bootstrap 4
stop
Ready
GO!
stop
Ready
GO!
Split Button in Bootstrap 4
Option
Edit
Hapus


How exactly does this thing work?
Reddit: Who doesn't like solving switch and lever puzzles to change you're volume?


Delivered To:
Summary:
Total:
NAMASTE PIZZA
Size Makes the Difference
Small
Medium
Large
Error Message
The Crust Is a must
Crispy
Stuffed
Gluten-free
Error Message
What`s Pizza without Toppings?
None
Mushrooms
Tikka Sauce
Chilli
Error Message
How many would you get?
Delivery Details
Where should we deliver
Self Pick-up @0
Nairobi @100
Nakuru @200
Thika @150
Naivasha @300
Kilimani @80
Add Pizza
Submit


Special Forces kill, detain 27 Taliban and ISIS militants in 6 provinces
by Khaama PressThe Afghan Special Forces killed 13 Taliban militants and arrested 14 others during separate operations in the past 24 hours.
The military officials said Tuesday the Special Forces killed 8 Taliban militants and destroyed a small cache of weapons in Baraki Barak district of Logar province.
The officials further added the Special Forces killed 5 Taliban militants and destroyed a cache of weapons during a separate raid in Gizab district of Daykundi province.
The Special Forces arrested 5 ISIS Khurasan militants and destroyed a small cache of weapons during a separate raid in Shinwar district of Nangarhar, the officials said, adding that the Special Forces arrested 3 Taliban militants during a separate raid in Deh-e Sabz district of Kabul.
The officials also added that the Special Forces arrested 3 Taliban militants and destroyed a small cache of weapons during an operation in Jaji district of Paktiya.
Author
-
The Khaama Press News Agency is the leading and largest English news service for Afghanistan with over 3 million hits a month. Independent authors/columnists and experts are welcomed to contribute stories, opinions and editorials. Send stories to news@khaama.com.


public class NativeSocketCommunicationSetup extends java.lang.Object implements TwoPartyCommunicationSetup, org.apache.commons.exec.TimeoutObserver
| Constructor and Description |
|---|
NativeSocketCommunicationSetup(PartyData me,
PartyData party)
A constructor that set the given parties.
|
| Modifier and Type | Method and Description |
|---|---|
void |
close()
This implementation has nothing to close besides the sockets (which are being closed by the channel instances).
|
void |
enableNagle()
Enables to use Nagle algorithm in the communication.
|
void |
enableNagleInChannels()
Enables Nagle's algorithm.
|
java.util.Map<java.lang.String,Channel> |
prepareForCommunication(int connectionsNum,
long timeOut)
An application that wants to use the communication layer will call this function in order to prepare for
communication after providing the required parameters.
|
java.util.Map<java.lang.String,Channel> |
prepareForCommunication(java.lang.String[] connectionsIds,
long timeOut)
Initiates the creation of the actual sockets connections between the parties.
|
void |
stopConnecting()
Sets the flag bStopped to false.
|
void |
timeoutOccured(org.apache.commons.exec.Watchdog w)
This function is called by the infrastructure of the Watchdog if the previously set timeout has passed.
|
public NativeSocketCommunicationSetup(PartyData me, PartyData party) throws DuplicatePartyException
me
- The data of the current application.party
- The data of the other application to communicate with.DuplicatePartyException
public java.util.Map<java.lang.String,Channel> prepareForCommunication(java.lang.String[] connectionsIds, long timeOut) throws java.util.concurrent.TimeoutException
prepareForCommunication
in interface TwoPartyCommunicationSetup
connectionsIds
- Each required connection's name.timeOut
- the maximum amount of time we allow for the connection stage.java.util.concurrent.TimeoutException
- in case a timeout has occurred before all channels have been connected.public java.util.Map<java.lang.String,Channel> prepareForCommunication(int connectionsNum, long timeOut) throws java.util.concurrent.TimeoutException
TwoPartyCommunicationSetup
The constructor of the concrete classes should receive the data of the two parties participate in the communication. After that, this function initiates the creation of the final actual connections between the parties.
Each connection has a unique name, that we call ID. This name used to distinguish between the created connections in order to make it easier and more convenient to understand what is the usage of each connection. In this function, the names of the connections are chosen by default, meaning the connections are numbered according to their index. i.e the first connection's name is "1", the second is "2" and so on.
If this function succeeds, the application may use the send and receive functions of the created channels to pass messages.
In this function, Nagle's algorithm is disabled; for cryptographic protocols this is typically much better. In order to use the Nagle algorithm, call the enableNagle() function.
prepareForCommunication
in interface TwoPartyCommunicationSetup
connectionsNum
- The number of requested connections.timeOut
- the maximum amount of time we allow for the connection stage.java.util.concurrent.TimeoutException
- in case a timeout has occurred before all channels have been connected.public void enableNagle()
TwoPartyCommunicationSetup
By default Nagle algorithm is disabled since it is much better for cryptographic algorithms.
enableNagle
in interface TwoPartyCommunicationSetup
public void timeoutOccured(org.apache.commons.exec.Watchdog w)
timeoutOccured
in interface org.apache.commons.exec.TimeoutObserver
public void stopConnecting()
public void close()
close
in interface TwoPartyCommunicationSetup
public void enableNagleInChannels()


How are you?
Meeting at 16:00 in the conference room.
No problem. Thank's for reminder!
No problem. The only thing i need is time.
Yep. We talked about it this morning.
Can't wait for the public launch!
Ok. Just let me know.
Fantastic...
I know. Fingers crossed!
Google AdWords 80%
Facebook 57%
SEO 60%
Instagram 23%


Tired of Booking Train Tickets? MERS is here with a solution for Fast and Efficient E-Rail Booking
Find Out MoreTrain Ticket Booking using IRCTC
Not happy with the present seat reservation? Apply for seat shift!!
Customized privileged Chat room for private contact!
Ask your queries here! We will get back to you in no time!
MERS provide you various features to make the process of E-Rail booking smart and pleasurable!
The platform is availbale throughout India and accessible to everyone across the country.
Learn more »MERS is unique and is available 24x7 for 365 days serving and creating happiness!
Learn more »MERS is one of a kind platform and has its own natural features for an efficient E-booking system.
Learn more »The unique algorthm of MERS makes it fast and efficient for its users to ease the process of E-Booking.
Learn more »Our Mobile friendly approach allows users to acces MERS from anywhere, everywhere with ease!.
Learn more »


While some thread-based servers such as Apache use a timeout when they wait for incomplete HTTP requests, it is set to 300 seconds by default and reset as soon as the client sends the rest of the data


Select all the sites you want Disengaged to modify, then save.
You will be asked for your permission when you save.
* You can revoke your permission at any time by unchecking and saving.


amount : 10 grams of kratom leaf finely powdered shared between two people.
I was given the opportunity of bioassaying some kratom recently from a distributor that imports it directly from indonesia.
X (the distributor) described an experience where he himself had taken 1 teaspoon (approximately 2 grams) of the material that had been steeped in a cup of boiled water for 20 minutes and drank material on an empty stomach. To quote him, ' I don't usually take anything now days but after that one spoon full I found myself completely fascinated with the television for close to four hours and I had the sound turned off! '
A plant made television interesting?! - That was enough to pique my curiousity.
I put 10 grams of Kratom into a coffee plunger and filled with enough boiled water for two cups and waited for 20 minutes to steep and cool.
I plunged the concoction to remove loose material floaties. A friend and I then shared an equal amount in two separate cups. The drink was bitter to taste although bearable.
We then went back to some tasks we were into at the time.
At about 20 minutes I started to feel euphoric and chatty although I was noticing a slight slur in my voice and a laziness in my desire to form words clearly. My friend noted an identical effect. We both agreed that the experience was definitely positive and had agreed to repeat the experience at a later time.
We enjoyed the space for about an hour and speculated on what it would be like if we took the rest of the material after again steeping it in some more hot water.
I added the hot water and let it steep for another 15 minutes before stirring vigorously and pouring out two cups.
We then each drank the material and water in one hasty gulp as the drink was close to very foul although I have drunk worse.
Within 15 minutes my body load experience increased and my mind alert and yet drowsy on other levels much like an opiate based stone. I was close to compelete immobility and a mind numbing stupor. The body load increased and I went into a nausea space noting that my brain felt split in two as my eyes were on the mildy acting independently as they do when I have had maoi's or mushrooms in the distant past.
It was unpleasant as I dont like this sort of space myself as I dont find it good for creativity.  So I rode it out for close to two and a half hours.
As I recovered the nausea faded with the other bodily discomforts.
During all this my friend had the luxury of having to deal with a long distance phone call at the time and later mentioned that he was having so much trouble that he nearly had to end the call.
Another friend in the room noted that he had not seen me in that sort of stoned space for well over ten years. Again... not a space I like to be in.
Upon reflection, it is definitely NOT a good idea to high dose on this substance for myself and I will next time take the recommended dose.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Rock Climbing is a sport that has been around for many years, it was in the 1880's that Europe
began to develop rock climbing as a sport separate from the traditional mountaineering.
There are many different types of rock climbing, my interests lye mostly in Bouldering
and Lead Climbing. I started climbing at the age
of 16 in my local climbing wall with my brother and father. My interest for the sport deepened when I joined
the UCC rock climbing/mountaineering club.
Rock Climbing is a competitive sport although I have no
interest in competing. There is also a standardised grading system in rock climbing, it ranges from 1 to 9a+.
Each route has a different difficulty, if you are capable of completing the climb then that is your grade.
I am a 5c on the grading scale.