Let's get started!
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image
from PIL import ImageDraw
from PIL import ImageColor
import time
from scipy.stats import norm
%matplotlib inline
plt.style.use('ggplot')
MobileNets, as the name suggests, are neural networks constructed for the purpose of running very efficiently (high FPS, low memory footprint) on mobile and embedded devices. MobileNets achieve this with 3 techniques:
These 3 techniques reduce the size of cummulative parameters and therefore the computation required. Of course, generally models with more paramters achieve a higher accuracy. MobileNets are no silver bullet, while they perform very well larger models will outperform them. MobileNets are designed for mobile devices, NOT cloud GPUs. The reason we're using them in this lab is automotive hardware is closer to mobile or embedded devices than beefy cloud GPUs.
Before we get into the MobileNet convolution block let's take a step back and recall the computational cost of a vanilla convolution. There are $N$ kernels of size $D_k * D_k$. Each of these kernels goes over the entire input which is a $D_f * D_f * M$ sized feature map or tensor (if that makes more sense). The computational cost is:
$$ D_g * D_g * M * N * D_k * D_k $$Let $D_g * D_g$ be the size of the output feature map. Then a standard convolution takes in a $D_f * D_f * M$ input feature map and returns a $D_g * D_g * N$ feature map as output.
(Note: In the MobileNets paper, you may notice the above equation for computational cost uses $D_f$ instead of $D_g$. In the paper, they assume the output and input are the same spatial dimensions due to stride of 1 and padding, so doing so does not make a difference, but this would want $D_g$ for different dimensions of input and output.)
A depthwise convolution acts on each input channel separately with a different kernel. $M$ input channels implies there are $M$ $D_k * D_k$ kernels. Also notice this results in $N$ being set to 1. If this doesn't make sense, think about the shape a kernel would have to be to act upon an individual channel.
Computation cost:
$$ D_g * D_g * M * D_k * D_k $$A pointwise convolution performs a 1x1 convolution, it's the same as a vanilla convolution except the kernel size is $1 * 1$.
Computation cost:
$$ D_k * D_k * D_g * D_g * M * N = 1 * 1 * D_g * D_g * M * N = D_g * D_g * M * N $$Thus the total computation cost is for separable depthwise convolution:
$$ D_g * D_g * M * D_k * D_k + D_g * D_g * M * N $$which results in $\frac{1}{N} + \frac{1}{D_k^2}$ reduction in computation:
$$ \frac {D_g * D_g * M * D_k * D_k + D_g * D_g * M * N} {D_g * D_g * M * N * D_k * D_k} = \frac {D_k^2 + N} {D_k^2*N} = \frac {1}{N} + \frac{1}{D_k^2} $$MobileNets use a 3x3 kernel, so assuming a large enough $N$, separable depthwise convnets are ~9x more computationally efficient than vanilla convolutions!
The 2nd technique for reducing the computational cost is the "width multiplier" which is a hyperparameter inhabiting the range [0, 1] denoted here as $\alpha$. $\alpha$ reduces the number of input and output channels proportionally:
$$ D_f * D_f * \alpha M * D_k * D_k + D_f * D_f * \alpha M * \alpha N $$The 3rd technique for reducing the computational cost is the "resolution multiplier" which is a hyperparameter inhabiting the range [0, 1] denoted here as $\rho$. $\rho$ reduces the size of the input feature map:
$$ \rho D_f * \rho D_f * M * D_k * D_k + \rho D_f * \rho D_f * M * N $$Combining the width and resolution multipliers results in a computational cost of:
$$ \rho D_f * \rho D_f * a M * D_k * D_k + \rho D_f * \rho D_f * a M * a N $$Training MobileNets with different values of $\alpha$ and $\rho$ will result in different speed vs. accuracy tradeoffs. The folks at Google have run these experiments, the result are shown in the graphic below:
MACs (M) represents the number of multiplication-add operations in the millions.
In this exercise you'll implement a separable depthwise convolution block and compare the number of parameters to a standard convolution block. For this exercise we'll assume the width and resolution multipliers are set to 1.
Docs:
def vanilla_conv_block(x, kernel_size, output_channels):
"""
Vanilla Conv -> Batch Norm -> ReLU
"""
x = tf.layers.conv2d(
x, output_channels, kernel_size, (2, 2), padding='SAME')
x = tf.layers.batch_normalization(x)
return tf.nn.relu(x)
def mobilenet_conv_block(x, kernel_size, output_channels):
"""
Depthwise Conv -> Batch Norm -> ReLU -> Pointwise Conv -> Batch Norm -> ReLU
"""
# assumes BHWC format
input_channel_dim = x.get_shape().as_list()[-1]
W = tf.Variable(tf.truncated_normal((kernel_size, kernel_size, input_channel_dim, 1)))
# depthwise conv
x = tf.nn.depthwise_conv2d(x, W, (1, 2, 2, 1), padding='SAME')
x = tf.layers.batch_normalization(x)
x = tf.nn.relu(x)
# pointwise conv
x = tf.layers.conv2d(x, output_channels, (1, 1), padding='SAME')
x = tf.layers.batch_normalization(x)
return tf.nn.relu(x)
Let's compare the number of parameters in each block.
# constants but you can change them so I guess they're not so constant :)
INPUT_CHANNELS = 32
OUTPUT_CHANNELS = 512
KERNEL_SIZE = 3
IMG_HEIGHT = 256
IMG_WIDTH = 256
with tf.Session(graph=tf.Graph()) as sess:
# input
x = tf.constant(np.random.randn(1, IMG_HEIGHT, IMG_WIDTH, INPUT_CHANNELS), dtype=tf.float32)
with tf.variable_scope('vanilla'):
vanilla_conv = vanilla_conv_block(x, KERNEL_SIZE, OUTPUT_CHANNELS)
with tf.variable_scope('mobile'):
mobilenet_conv = mobilenet_conv_block(x, KERNEL_SIZE, OUTPUT_CHANNELS)
vanilla_params = [
(v.name, np.prod(v.get_shape().as_list()))
for v in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, 'vanilla')
]
mobile_params = [
(v.name, np.prod(v.get_shape().as_list()))
for v in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, 'mobile')
]
print("VANILLA CONV BLOCK")
total_vanilla_params = sum([p[1] for p in vanilla_params])
for p in vanilla_params:
print("Variable {0}: number of params = {1}".format(p[0], p[1]))
print("Total number of params =", total_vanilla_params)
print()
print("MOBILENET CONV BLOCK")
total_mobile_params = sum([p[1] for p in mobile_params])
for p in mobile_params:
print("Variable {0}: number of params = {1}".format(p[0], p[1]))
print("Total number of params =", total_mobile_params)
print()
print("{0:.3f}x parameter reduction".format(total_vanilla_params /
total_mobile_params))
Your solution should show the majority of the parameters in MobileNet block stem from the pointwise convolution.
In this section you'll use a pretrained MobileNet SSD model to perform object detection. You can download the MobileNet SSD and other models from the TensorFlow detection model zoo (note: we'll provide links to specific models further below). Paper describing comparing several object detection models.
Alright, let's get into SSD!
Many previous works in object detection involve more than one training phase. For example, the Faster-RCNN architecture first trains a Region Proposal Network (RPN) which decides which regions of the image are worth drawing a box around. RPN is then merged with a pretrained model for classification (classifies the regions). The image below is an RPN:
The SSD architecture is a single convolutional network which learns to predict bounding box locations and classify the locations in one pass. Put differently, SSD can be trained end to end while Faster-RCNN cannot. The SSD architecture consists of a base network followed by several convolutional layers:
NOTE: In this lab the base network is a MobileNet (instead of VGG16.)
SSD operates on feature maps to predict bounding box locations. Recall a feature map is of size $D_f * D_f * M$. For each feature map location $k$ bounding boxes are predicted. Each bounding box carries with it the following information:
SSD does not predict the shape of the box, rather just where the box is. The $k$ bounding boxes each have a predetermined shape. This is illustrated in the figure below:
The shapes are set prior to actual training. For example, In figure (c) in the above picture there are 4 boxes, meaning $k$ = 4.
It would be a good exercise to read the SSD paper prior to a answering the following questions.
Q: Why does SSD use several differently sized feature maps to predict detections?
A: Your answer here
The current approach leaves us with thousands of bounding box candidates, clearly the vast majority of them are nonsensical.
Q: What are some ways which we can filter nonsensical bounding boxes?
A: Your answer here
With the final set of matched boxes we can compute the loss:
$$ L = \frac {1} {N} * ( L_{class} + L_{box}) $$where $N$ is the total number of matched boxes, $L_{class}$ is a softmax loss for classification, and $L_{box}$ is a L1 smooth loss representing the error of the matched boxes with the ground truth boxes. L1 smooth loss is a modification of L1 loss which is more robust to outliers. In the event $N$ is 0 the loss is set 0.
In this part of the lab you'll detect objects using pretrained object detection models. You can download the latest pretrained models from the model zoo, although do note that you may need a newer version of TensorFlow (such as v1.8) in order to use the newest models.
We are providing the download links for the below noted files to ensure compatibility between the included environment file and the models.
RFCN_ResNet101 11.6.17 version
Faster_RCNN_Inception_ResNet 11.6.17 version
Make sure to extract these files prior to continuing!
# Frozen inference graph files. NOTE: change the path to where you saved the models.
SSD_GRAPH_FILE = 'ssd_mobilenet_v1_coco_11_06_2017/frozen_inference_graph.pb'
RFCN_GRAPH_FILE = 'rfcn_resnet101_coco_11_06_2017/frozen_inference_graph.pb'
FASTER_RCNN_GRAPH_FILE = 'faster_rcnn_inception_resnet_v2_atrous_coco_11_06_2017/frozen_inference_graph.pb'
Below are utility functions. The main purpose of these is to draw the bounding boxes back onto the original image.
# Colors (one for each class)
cmap = ImageColor.colormap
print("Number of colors =", len(cmap))
COLOR_LIST = sorted([c for c in cmap.keys()])
#
# Utility funcs
#
def filter_boxes(min_score, boxes, scores, classes):
"""Return boxes with a confidence >= `min_score`"""
n = len(classes)
idxs = []
for i in range(n):
if scores[i] >= min_score:
idxs.append(i)
filtered_boxes = boxes[idxs, ...]
filtered_scores = scores[idxs, ...]
filtered_classes = classes[idxs, ...]
return filtered_boxes, filtered_scores, filtered_classes
def to_image_coords(boxes, height, width):
"""
The original box coordinate output is normalized, i.e [0, 1].
This converts it back to the original coordinate based on the image
size.
"""
box_coords = np.zeros_like(boxes)
box_coords[:, 0] = boxes[:, 0] * height
box_coords[:, 1] = boxes[:, 1] * width
box_coords[:, 2] = boxes[:, 2] * height
box_coords[:, 3] = boxes[:, 3] * width
return box_coords
def draw_boxes(image, boxes, classes, thickness=4):
"""Draw bounding boxes on the image"""
draw = ImageDraw.Draw(image)
for i in range(len(boxes)):
bot, left, top, right = boxes[i, ...]
class_id = int(classes[i])
color = COLOR_LIST[class_id]
draw.line([(left, top), (left, bot), (right, bot), (right, top), (left, top)], width=thickness, fill=color)
def load_graph(graph_file):
"""Loads a frozen inference graph"""
graph = tf.Graph()
with graph.as_default():
od_graph_def = tf.GraphDef()
with tf.gfile.GFile(graph_file, 'rb') as fid:
serialized_graph = fid.read()
od_graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(od_graph_def, name='')
return graph
Below we load the graph and extract the relevant tensors using get_tensor_by_name
. These tensors reflect the input and outputs of the graph, or least the ones we care about for detecting objects.
detection_graph = load_graph(SSD_GRAPH_FILE)
# detection_graph = load_graph(RFCN_GRAPH_FILE)
# detection_graph = load_graph(FASTER_RCNN_GRAPH_FILE)
# The input placeholder for the image.
# `get_tensor_by_name` returns the Tensor with the associated name in the Graph.
image_tensor = detection_graph.get_tensor_by_name('image_tensor:0')
# Each box represents a part of the image where a particular object was detected.
detection_boxes = detection_graph.get_tensor_by_name('detection_boxes:0')
# Each score represent how level of confidence for each of the objects.
# Score is shown on the result image, together with the class label.
detection_scores = detection_graph.get_tensor_by_name('detection_scores:0')
# The classification of the object (integer id).
detection_classes = detection_graph.get_tensor_by_name('detection_classes:0')
Run detection and classification on a sample image.
# Load a sample image.
image = Image.open('./assets/sample1.jpg')
image_np = np.expand_dims(np.asarray(image, dtype=np.uint8), 0)
with tf.Session(graph=detection_graph) as sess:
# Actual detection.
(boxes, scores, classes) = sess.run([detection_boxes, detection_scores, detection_classes],
feed_dict={image_tensor: image_np})
# Remove unnecessary dimensions
boxes = np.squeeze(boxes)
scores = np.squeeze(scores)
classes = np.squeeze(classes)
confidence_cutoff = 0.8
# Filter boxes with a confidence score less than `confidence_cutoff`
boxes, scores, classes = filter_boxes(confidence_cutoff, boxes, scores, classes)
# The current box coordinates are normalized to a range between 0 and 1.
# This converts the coordinates actual location on the image.
width, height = image.size
box_coords = to_image_coords(boxes, height, width)
# Each class with be represented by a differently colored box
draw_boxes(image, box_coords, classes)
plt.figure(figsize=(12, 8))
plt.imshow(image)
The model zoo comes with a variety of models, each its benefits and costs. Below you'll time some of these models. The general tradeoff being sacrificing model accuracy for seconds per frame (SPF).
def time_detection(sess, img_height, img_width, runs=10):
image_tensor = sess.graph.get_tensor_by_name('image_tensor:0')
detection_boxes = sess.graph.get_tensor_by_name('detection_boxes:0')
detection_scores = sess.graph.get_tensor_by_name('detection_scores:0')
detection_classes = sess.graph.get_tensor_by_name('detection_classes:0')
# warmup
gen_image = np.uint8(np.random.randn(1, img_height, img_width, 3))
sess.run([detection_boxes, detection_scores, detection_classes], feed_dict={image_tensor: gen_image})
times = np.zeros(runs)
for i in range(runs):
t0 = time.time()
sess.run([detection_boxes, detection_scores, detection_classes], feed_dict={image_tensor: image_np})
t1 = time.time()
times[i] = (t1 - t0) * 1000
return times
with tf.Session(graph=detection_graph) as sess:
times = time_detection(sess, 600, 1000, runs=10)
# Create a figure instance
fig = plt.figure(1, figsize=(9, 6))
# Create an axes instance
ax = fig.add_subplot(111)
plt.title("Object Detection Timings")
plt.ylabel("Time (ms)")
# Create the boxplot
plt.style.use('fivethirtyeight')
bp = ax.boxplot(times)
Finally run your pipeline on this short video.
# Import everything needed to edit/save/watch video clips
from moviepy.editor import VideoFileClip
from IPython.display import HTML
HTML("""
<video width="960" height="600" controls>
<source src="{0}" type="video/mp4">
</video>
""".format('driving_no_audio.mp4'))
Run an object detection pipeline on the above clip.
# clip = VideoFileClip('driving.mp4')
# Due to some issues with audio codec, this is stripped from audio
clip = VideoFileClip('driving_no_audio.mp4')
def pipeline(img):
draw_img = Image.fromarray(img)
boxes, scores, classes = sess.run([detection_boxes, detection_scores, detection_classes], feed_dict={image_tensor: np.expand_dims(img, 0)})
# Remove unnecessary dimensions
boxes = np.squeeze(boxes)
scores = np.squeeze(scores)
classes = np.squeeze(classes)
confidence_cutoff = 0.8
# Filter boxes with a confidence score less than `confidence_cutoff`
boxes, scores, classes = filter_boxes(confidence_cutoff, boxes, scores, classes)
# The current box coordinates are normalized to a range between 0 and 1.
# This converts the coordinates actual location on the image.
width, height = draw_img.size
box_coords = to_image_coords(boxes, height, width)
# Each class with be represented by a differently colored box
draw_boxes(draw_img, box_coords, classes)
return np.array(draw_img)
with tf.Session(graph=detection_graph) as sess:
image_tensor = sess.graph.get_tensor_by_name('image_tensor:0')
detection_boxes = sess.graph.get_tensor_by_name('detection_boxes:0')
detection_scores = sess.graph.get_tensor_by_name('detection_scores:0')
detection_classes = sess.graph.get_tensor_by_name('detection_classes:0')
new_clip = clip.fl_image(pipeline)
# write to file
new_clip.write_videofile('result.mp4')
HTML("""
<video width="960" height="600" controls>
<source src="{0}" type="video/mp4">
</video>
""".format('result.mp4'))
Some ideas to take things further:


Gold Prices News: XAU/USD still under immense bear pressure, levels
by Yohay ElamGold Technical Analysis: Bears aim toward multi-month lows around $1445
Gold has added to the previous session's modest losses. It has remained under some selling pressure for the second consecutive session on Monday – erasing all of the gains recorded last week. Read more...
Is Gold losing its way?
Gold Futures have continued their losing ways, refreshing the 3-month down channel by reversing last week’s gains below $1,459.00. The rejection at the 20-day SMA could alert market participants to the prospect of a move below the $1,445.00 which will shift the medium-term outlook completely into a negative one. Read more...
Market Optimism Keeps Gold Under Pressure
Early in a new November week, Gold is consolidating at 1465.60. Market players are on standby: there won’t be any serious dynamics in the instrument until media reports some more or less interesting news on the US-China trade agreement. Read more...


Site list help:
Sites, queues, GOC names
PanDA submits jobs to 'PanDA sites'.
It submits jobs via pilots running on queues defined in a PanDA site database;
there is typically but not necessarily a 1:1 correspondence between site and associated queue. These are the queues shown above.
PanDA sites are hosted at facilities that (generally) are part of the WLCG computing infrastructure, and have a name (GOC name) within that infrastructure.
Tier levels
Sites are categorized by the familiar Tier 0, Tier 1, Tier 2, Tier 3 levels. A further subcategorization is T2D;
these are Tier 2s where "D" stays for “Directly connected" and are validated for heavy duty workloads.
Online, offline, brokeroff, test
Online sites are up and running, able to accept jobs via automatic brokerage or direct assignment.
Brokeroff sites accept jobs only by direct assignment.
Test sites accept only test jobs. Offline sites accept no jobs at all.
The comment field often gives an indication of how the site wound up with the status it presently has.
Very often this comment indicates that the Hammercloud (HC) automated testing and blacklisting system has taken action.
Where sites are served by queues that have maximum allowed memory allocations and/or job execution times, they are so indicated.


Concentration of 311 requests from residents
311 is Charlotte-Mecklenburg's phone and web resource for service requests, bill payments, questions, comments and concerns. The 311 service makes government services more accessible and transparent, and is a key component of the city and county's culture of community engagement. 311 makes it easy for people to get involved in the community by picking up a phone or going online to report a problem or concern. That engagement makes a visible difference in the community, for example, when graffiti is removed from a park or a vacant property is cleaned up. Tracking 311 calls can assist neighborhoods and residents in identifying repeated problems and developing strategies to address them.
####Did you know? Char-Meck 311 is staffed 7 a.m. to 8 p.m. 365 days per year. The call center handled 227,390 requests in fiscal year 2013.
####Related variables
Nuisance Violations
Housing Code Violations
Neighborhood Organizations
Residential Occupancy
Number of calls and online requests to Char-Meck 311 divided by the total population, multiplied by 100.
Source: City of Charlotte Char-Meck 311
| Resource | Learn More and Take Action |
|---|---|
| Services Available Through 311 | Find all of 311's services here. |
| 311 Home | All of 311's services are also available online. |
| Open 311 | Learn about this national model and open standard for civic issue tracking, and see where it's being used. |
| Engagement through 311 | Research exploring the potential for 311 to facilitate community engagement. |


{% extends "base.html" %} {% block content %} {% if user_profile %}
Some quick example text to build on the card title and make up the bulk of the card's content.


|
|
unsigned char | version |
| |
|
unsigned char | offsetOfData |
| |
|
unsigned long | serialNumber |
| |
|
unsigned char | year |
| |
|
unsigned char | month |
| |
|
unsigned char | day |
| |
|
unsigned char | hour |
| |
|
unsigned char | minute |
| |
|
unsigned char | seconds |
| |
|
unsigned short | microSeconds100 |
| |
|
unsigned short | nBeams |
| |
|
unsigned long | error |
| |
|
DVLstatus | status |
| |
|
float | soundSpeed |
| |
|
float | temperature |
| |
|
float | pressure |
| |
|
float | velBeam [4] |
| |
|
float | distBeam [4] |
| |
|
float | fomBeam [4] |
| |
|
float | timeDiff1Beam [4] |
| |
|
float | timeDiff2Beam [4] |
| |
|
float | timeVelEstBeam [4] |
| |
|
float | velX |
| |
|
float | velY |
| |
|
float | velZ1 |
| |
|
float | velZ2 |
| |
|
float | fomX |
| |
|
float | fomY |
| |
|
float | fomZ1 |
| |
|
float | fomZ2 |
| |
|
float | timeDiff1X |
| |
|
float | timeDiff1Y |
| |
|
float | timeDiff1Z1 |
| |
|
float | timeDiff1Z2 |
| |
|
float | timeDiff2X |
| |
|
float | timeDiff2Y |
| |
|
float | timeDiff2Z1 |
| |
|
float | timeDiff2Z2 |
| |
|
float | timeVelEstX |
| |
|
float | timeVelEstY |
| |
|
float | timeVelEstZ1 |
| |
|
float | timeVelEstZ2 |
| |
The documentation for this struct was generated from the following file:
- hardware_layer/hardware_dvl_ethernet/include/dvl_data.h


• Your name and title?
• What do you hope to get out of today?
• Understand where your data is touching, and who can see it.
• Some feasible next steps.
• A basic introduction to digital security.
• Activities: on digital security and your organization.
• Discussion: Addressing your survey feedback.
• Presentation: Need to knows for security.
• Arrange yourselves in 4-5 groups
• Post-its, sharpies
• We will ask you to look over scenarios in a moment
• You will discuss in your groups
• You will share what you discuss after
example:
You send a text message to a friend.
Which people? What devices? What networks? What companies?
• Which people?
• What devices?
• What networks?
• What companies?
• Anything else to consider?
1) [task]
2) [task]
3) [task]
4) [task]
In each of these scenarios...
• Think about what is valuable information.
• Think about where organizational data passes through.
• What information do you want to keep private?
• Who are you protecting that information from?
• What can they do to find out?
• What happens if they succeed?
• What information do you want to keep private?
• Who are you protecting that information from?
• What can they do to find out?
• What happens if they succeed?
• How much are you willing to go through to protect that information?
• How realistic is that threat?
Reviewing some questions from your survey.
Basic recommendations.
encrypts every single file on your devices
• Protects all data on your computer, when your computer is turned off.
• Use case: Protects if computer is seized or stolen
• Very important notes: 1) Make backups before enabling full-disk encryption! 2) REMEMBER YOUR PASSWORD and write it down somewhere until you memorize it.
• Use FileVault!
• Protects all data on your phone, when locked.
• Protects if phone is seized or stolen.
• Have a good password (NOT biometric fingerprint) to protect your phone!
• double-check the URL (without clicking on it!)
• copy and paste the link into a notepad to see the true link
Be wary of link shorteners
• Be careful to not download/open attachments, even if it is juicy looking info.
• Instead, use a cloud-based service like Google Drive to preview an attachment.
• Update your software regularly.
• Don't plug in unfamiliar CDs/DVDs/USBs/chargers in your devices.
• Be mindful when downloading software and apps (consider how much you trust the source).
• generally 4+ words
• unique
• long
• random
• hard for computers and people to guess
• easy for you to remember
• Lots of options available, e.g. KeePass, LastPass.
• Encrypts your passwords.
• Just requires one passphrase (master passphrase) to remember, which unlocks the others.
• Great for saving regular passwords and security questions.
(goes by a few different names)
• "Something that you know (password) + something that you have (phone or other tool)"
• Adds an extra layer of login security.
• help prevent someone on the same Internet connection from snooping on your Internet traffic
• log what you do.
• scrambles message content (fun!)
• but still has metadata (not as fun!)
• end-to-end encryption: very important
• end-to-end encrypted
• phone & text messaging
• photo & video sharing
• free downloadable app
• open source
• If you upload your data to a cloud service—Google Drive, Dropbox, iCloud—that data can potentially be read by the service provider.
• Law enforcement can send a subpoena to the provider for the data.
• Depending on your threat model, you may not want to upload to cloud services.
• threat modeling
• protecting data
• phishing
• making strong passphrases and password managers
• 2-Factor Authentication
• HTTPS and VPNs
• digital communication and encryption
• Signal
This is a very basic security talk. This may not be all you need to protect yourself online.
Depending on your threat model, you may need additional tools. Check out ssd.eff.org for more information.
Find this slideshow at:
https://eff-soraya.github.io/student-journalist-slides/#/
If you're concerned about anonymity, Tor is great because:
• Clears search history each session.
• Goes through a different IP address that is hard to route back to the initial user.
• Removes browser identifiability (if you use it correctly).
• Blocks javascript by default.
• Has HTTPS Everywhere enabled.
• Run by a nonprofit and dedicated volunteers.
Want to get HTTPS for your site? Ask your systems administrator (or a tech-savvy server-aware friend) for help installing Certbot. Certbot is free!
Online trackers and sites themselves may be able to identify you – even if you’ve installed software to protect yourself.
It’s possible to configure your browser to thwart tracking, but many people don’t know how.


Hi there!
I have helped startups & enterprises build great web and mobile apps over the last decade 🚀


| Package | Description |
|---|---|
| org.apache.taverna.scufl2.rdfxml | |
| org.apache.taverna.scufl2.xml |
| Class and Description |
|---|
| Activity
Java class for anonymous complex type.
|
| Blocking
Java class for Blocking complex type.
|
| Configuration
Java class for anonymous complex type.
|
| CrossProduct
Java class for anonymous complex type.
|
| DataLink
Java class for DataLink complex type.
|
| DispatchStack
Java class for anonymous complex type.
|
| DotProduct
Java class for anonymous complex type.
|
| InputActivityPort
Java class for anonymous complex type.
|
| InputPortBinding
Java class for InputPortBinding complex type.
|
| InputProcessorPort
Java class for anonymous complex type.
|
| InputWorkflowPort
Java class for anonymous complex type.
|
| IterationStrategyStack
Java class for anonymous complex type.
|
| OutputActivityPort
Java class for anonymous complex type.
|
| OutputPortBinding
Java class for OutputPortBinding complex type.
|
| OutputProcessorPort
Java class for anonymous complex type.
|
| OutputWorkflowPort
Java class for anonymous complex type.
|
| PortNode
Java class for anonymous complex type.
|
| Processor
Java class for anonymous complex type.
|
| ProcessorBinding
Java class for anonymous complex type.
|
| ProductOf
Java class for anonymous complex type.
|
| Profile
Java class for anonymous complex type.
|
| ProfileDocument
Java class for ProfileDocument complex type.
|
| Workflow
Java class for anonymous complex type.
|
| WorkflowBundle
Java class for anonymous complex type.
|
| Class and Description |
|---|
| Activity
Java class for anonymous complex type.
|
| Activity.InputActivityPort
Java class for anonymous complex type.
|
| Activity.OutputActivityPort
Java class for anonymous complex type.
|
| Blocking
Java class for Blocking complex type.
|
| Configuration
Java class for anonymous complex type.
|
| ConfigurationType
Java class for anonymous complex type.
|
| Control
Java class for anonymous complex type.
|
| CrossProduct
Java class for anonymous complex type.
|
| DataLink
Java class for DataLink complex type.
|
| DataLink.MergePosition
Java class for anonymous complex type.
|
| DataLinkEntry
Java class for anonymous complex type.
|
| DispatchStack
Java class for anonymous complex type.
|
| DispatchStack.DispatchStackLayers
Java class for anonymous complex type.
|
| DispatchStackLayer
Java class for anonymous complex type.
|
| DotProduct
Java class for anonymous complex type.
|
| GranularPortDepth
Java class for anonymous complex type.
|
| InputActivityPort
Java class for anonymous complex type.
|
| InputPortBinding
Java class for InputPortBinding complex type.
|
| InputProcessorPort
Java class for anonymous complex type.
|
| InputWorkflowPort
Java class for anonymous complex type.
|
| IterationStrategyStack
Java class for anonymous complex type.
|
| IterationStrategyStack.IterationStrategies
Java class for anonymous complex type.
|
| OutputActivityPort
Java class for anonymous complex type.
|
| OutputPortBinding
Java class for OutputPortBinding complex type.
|
| OutputProcessorPort
Java class for anonymous complex type.
|
| OutputWorkflowPort
Java class for anonymous complex type.
|
| PortDepth
Java class for anonymous complex type.
|
| PortNode
Java class for anonymous complex type.
|
| PortNode.DesiredDepth
Java class for anonymous complex type.
|
| Processor
Java class for anonymous complex type.
|
| Processor.DispatchStack
Java class for anonymous complex type.
|
| Processor.InputProcessorPort
Java class for anonymous complex type.
|
| Processor.IterationStrategyStack
Java class for anonymous complex type.
|
| Processor.OutputProcessorPort
Java class for anonymous complex type.
|
| ProcessorBinding
Java class for anonymous complex type.
|
| ProcessorBinding.ActivityPosition
Java class for anonymous complex type.
|
| ProcessorBinding.InputPortBinding
Java class for anonymous complex type.
|
| ProcessorBinding.OutputPortBinding
Java class for anonymous complex type.
|
| ProductOf
Java class for anonymous complex type.
|
| Profile
Java class for anonymous complex type.
|
| ProfileDocument
Java class for ProfileDocument complex type.
|
| Required
Java class for anonymous complex type.
|
| SeeAlsoType
Java class for SeeAlsoType complex type.
|
| Workflow
Java class for anonymous complex type.
|
| Workflow.InputWorkflowPort
Java class for anonymous complex type.
|
| Workflow.OutputWorkflowPort
Java class for anonymous complex type.
|
| Workflow.Processor
Java class for anonymous complex type.
|
| WorkflowBundle
Java class for anonymous complex type.
|
| WorkflowBundle.Profile
Java class for anonymous complex type.
|
| WorkflowBundle.Workflow
Java class for anonymous complex type.
|
| WorkflowBundleDocument
Java class for WorkflowBundleDocument complex type.
|
| WorkflowDocument
Java class for WorkflowDocument complex type.
|
Copyright © 2015–2016 The Apache Software Foundation. All rights reserved.


| Method | Sample Request | Sample Response | Description | |
|---|---|---|---|---|
User Routes |
||||
| GET |
/api/v3/user/all |
"[]" |
gets all the users in the database | |
| GET |
/api/v3/user/id/:id ex. /api/v3/user/id/2 |
"[]" |
returns "null" if there is no user found there. | |
| POST |
@/api/v3/user/new { username: 'alan', password: 'password' } |
{ "user": { "id": 1, "username": "alan", "updatedAt": "2017-09-03T16:12:45.258Z", "createdAt": "2017-09-03T16:12:45.258Z" }, "created": true } // *"created" will be false, //if username is already taken |
Required POST keys: "username" & "password". If missing either, you will get an array of error message strings. | |
| POST |
@/api/v3/user/take-quiz { userId: 3, quizId: 4, score: 95.25 } |
"[]" |
required POST: userId, quizId, score. If you're missing any of the required parameters, then you will get an error message as a string (array of error strings). If not a valid quiz or valid user you'll get an object ex. `{"error": "Error! Need a valid quiz"}` | |
Quiz Routes |
||||
| GET | /api/v3/quiz/all |
[ { "id": 2, "title": "'this is a test quiz'", "description": null, "madeBy": 1, "createdAt": "2017-09-03T17:29:13.826Z", "updatedAt": "2017-09-03T17:29:13.826Z" } ] |
heres the description of what it does right? | |
| GET | /api/v3/quiz/id/:id |
{ "id": 2, "title": "'this is a test quiz'", "description": null, "madeBy": 1, "createdAt": "2017-09-03T17:29:13.826Z", "updatedAt": "2017-09-03T17:29:13.826Z", "questions": [ { "id": 1, "quizId": 2, "question": "Is this a valid question yo?", "choices": [ "yes", "no" ], "correctAnswer": 0, "createdAt": "2017-09-03T17:50:11.420Z", "updatedAt": "2017-09-03T17:50:11.420Z" } ] } |
Returns 'null' if there is no quiz with that id. | |
| POST | @/api/v3/quiz/new { "title": 'this is a test quiz', "madeBy": 1 // user Primary Key } |
{ "quiz": { "id": 2, "title": "'this is a test quiz'", "madeBy": 1, "updatedAt": "2017-09-03T17:29:13.826Z", "createdAt": "2017-09-03T17:29:13.826Z", "description": null }, "created": true, } |
If its not created, "quiz" will be an empty object & "created" will be false | |
| POST | @/api/v3/quiz/:id/question/new { "question": "Is this a valid question yo?", "choices": ["yes", "no"], "correctAnswer": 0 } |
{ "id": 1, "question": "Is this a valid question yo?", "choices": [ "yes", "no" ], "correctAnswer": 0, "quizId": 2, "updatedAt": "2017-09-03T17:50:11.420Z", "createdAt": "2017-09-03T17:50:11.420Z" } |
If not a valid quiz, returns an { "error": "Not a valid quizId"}. If missing any of the required parameters, it will return an array of error messages. | |
Vote Routes |
||||
| POST | @/api/v3/vote/new { "userId": 1, "quizId": 2, "stars": 4 } |
{ "vote": { "userId": 1, "quizId": 2, "stars": 4, "updatedAt": "2017-09-03T18:46:08.575Z", "createdAt": "2017-09-03T18:46:08.575Z" }, "created": true } // if user already voted for a quiz // created will be false, but gets updated |
If missing any of the required parameters, returns an array of error message strings. Currently will update the vote if user already voted. | |
| POST | @/api/v3/vote/update { "vote": { "stars": "1", "quizId": "2", "userId": "1" }, "updated": true } |
{ "vote": { "stars": "1", "quizId": "2", "userId": "1" }, "updated": true } //*If there is an error, updated will be false |
If missing any of the required parameters, returns an array of error message strings. This route may be combined with the previous POST a new vote route. |


Before Change
// Get predictions but not full rankings for the sake of speed
if cand_vecs.dim() == 2:
preds = [cands[ordering[0]] for ordering in ranks]
elif cand_vecs.dim() == 3:
preds = [cands[i][ordering[0]] for i, ordering in enumerate(ranks)]
return Output(preds)
After Change
self.metrics["rank"] += 1 + rank
self.metrics["mrr"] += 1.0 / (1 + rank)
ranks = ranks.cpu()
// Here we get the top prediction for each example, but do not
// return the full ranked list for the sake of training speed
preds = []
for i, ordering in enumerate(ranks):


“I have always imagined that Paradise will be a kind of library.”
― Jorge Luis Borges
“A room without books is like a body without a soul.”
– Cicero
“Books are a uniquely portable magic.”
– Stephen King
❮
❯
Davinci Code
Dan Brown
20$
The Shinning
Stephen King
20$
Loard Of the Rings
J.R.R Tolkien
20$


A passage appears at a point of your choice that you can see on a w ooden, plaster, or stone surface (such as a wall, a ceiling, or a floor) within range, and lasts for the duration. You choose the opening's dimensions: up to 5 feet wide, 8 feet tall, and 20 feet deep. The passage creates no instability in a structure surrounding it.
When the opening disappears, any creatures or objects still in the passage created by the spell are safely ejected to an unoccupied space nearest to the surface on which you cast the spell.


Opps, no result for these key words
Sorry, no one publish slides yet! Would you want to be the pioneer?
Sorry, you don't have any slides yet!
Sorry, no one private slides


Documentation v1.0
Introduction
Shreyu is a fully featured premium admin template built on top of awesome Bootstrap 4.3.1. It's crafted using modern web technologies HTML5, CSS3 and jQuery. The theme includes beautiful dashboard, many ready to use hand crafted components, widgets, pages, etc. The components can be used very easily on any page. The theme is fully responsive and customizable. This documentation is guidelines for all users who can even be a beginner or experienced web developer.
Thank you very much for considering Shreyu. We really care for our buyers and so in case if you are having any question or feedback, please feel free to get back to us via email<EMAIL_ADDRESS>or by filling out the contact form on our website.
What's included
Extract the zip file you received after purchase and you would find the exact below files and folders:
-
shreyu
- ├──
dist
- A pre-compiled folder containing html, assets including css, js, etc -
├──
src
- ├──
fonts
- fonts files - ├──
images
- images files - ├──
html
- ├──
partials
- partials - including top bar, left sidebar, menus, etc - ├──
templates
- reusable partials templates e.g. dashboard
- ├──
- ├──
js
- all javascript files - ├──
scss
- all scss (sass) files
- ├──
- ├──
gulpfile.js
- ├──
package.json
- ├──
package-lock.json
- ├──
README.md
- ├──
Pre-requisites
We are using gulp. It allows to have complete automatation for build. In case if you don't know - Gulp is a a toolkit for automating painful or time-consuming tasks in frontend development workflow, so you can stop messing around and build something. You can read it more about it here. Please follow below steps to install and setup all pre-requisites:
- Nodejs
Make sure to have the Node.js installed & running in your computer. If you already have installed nodejs on your computer, you can skip this step.
-
Yarn
Yarn is a package manager and dependency management. It allows easy management of all the third party dependency and plugins.
Make sure to have the Yarn installed & running in your computer. If you already have installed yarn on your computer, you can skip this step.
- Gulp
Make sure to have the Gulp installed & running in your computer. If you already have installed gulp on your computer, you can skip this step.
- Git
Make sure to have the Git installed & running in your computer. If you already have installed git on your computer, you can skip this step
Getting Started
Once you have all pre-requisites installed and running, you are ready to get start with the template. First, go to the root folder (the folder created when you extract the zip) where the package.json is available and run the following command:
yarn install
This will download all required dependencies defined in package.json
file. Once it
finished running the command, it will generate a folder name
node_modules
where you'll be able to see downloaded
packages.
Now you're good to go in running the template and view it in browser by running the command below:
yarn start
The template should be up and running in your browser.
You can also create a production ready build by running the command below:
yarn build
This will create a folder named dist
in same folder.
You
might want to take this folder and deploy on root of your web
server.
Customization
You can easily customize various elements including navbar, topbar,
form
elements etc by simply editing Sass files available in
/src/scss
directory. You can also remove unneeded
components from
app.scss
file.
How to add new page?
We have provided a starter page (check
src/html/pages-starter.html
) which helps you to
create new page. Please
note following some important points.
-
Make sure that you have included
css/bootstrap.min.css,css/app.min.css, css/icons.min.css
andjs/vendor.min.js, js/app.min.js
in your html - Most of the default/basic form elements along with few advanced elements are available and bundled in the above css and js and so you don't need to include any css or js separately.
- Note that, few elements e.g. charts, data tables, calendar, maps etc. requires you to include corresponding css and js files in your html.
How to change colors?
In order to change colors (including primary, secondary, success, info, danger, warning, etc.), do the following:
- A file
src/scss/_variables.scss
is containing the overridden colors and other configurations of bootstrap. You can change any values here and it would get reflected in any bootstrap based components or elements.
How to change footer?
In order to add, change or remove any ui elements from
footer or
sidebar, simply edit in file
src/html/partials/footer.html
. The change would
be reflected in all files automatically.
Layout and Sidebar
You can change or customize the overall layout or left side navigation easily. There are examples available for horizontal nav, dark theme, RTL, condensed side nav, fixed width (boxed), etc. You can check them under layouts menu option. Additionally, you can also modify the left side nav, topbar, etc.
How to change left side nav width?
In order to change the width of left side navigation bar, open a
file
src/scss/_variables.scss
and change the value of
variable
$leftbar-width
. The default value is set to
240px
.
How to change background or menu text color?
In order to change the background color, open a file
src/scss/scss/_variables.scss
and change the value
of
variable
$bg-leftbar-light
the default light value is set to
#ffffff
, $bg-leftbar-dark
the default
dark
value is set to
#323742
.
When you change the background color, you might want to change
the
color of menu accordingly. To change
the color of menu item, change the variable
$menu-item
(Default is set to #4B4B5A
).
Similarly, change the value of variables
$menu-item-hover
and
$menu-item-active
.
You can change other styles by making modifications in
src/scss/custom/structure/_left-menu.scss
.
Change Log
1.0.0 - 27 Oct, 2019
- Initial release


SHIFTA(3) - [BIT:SHIFT] Right shift with fill
result = shifta(i, shift )
elemental integer(kind=KIND) function shifta(i, shift)integer(kind=KIND),intent(in) :: i integer(kind=**),intent(in) :: shift
o a kind designated as ** may be any supported kind for the type o I is an integer of any kind o SHIFT is an integer of any kind o the result will automatically be of the same type, kind and rank as I.
SHIFTA(3) returns a value corresponding to I with all of the bits shifted right by SHIFT places and the vacated bits on the left filled with the value of the original left-most bit.
o I : The initial value to shift and fill o SHIFT : how many bits to shift right. It shall be nonnegative and less than or equal to BIT_SIZE(I). or the value is undefined. If SHIFT is zero the result is I.
The result has the value obtained by shifting the bits of I to the right SHIFT bits and replicating the leftmost bit of I in the left SHIFT bits (Note the leftmost bit in "twos complement" representation is the sign bit).
Bits shifted out from the right end are lost.
If SHIFT is zero the result is I.
Sample program:
program demo_shifta use,intrinsic :: iso_fortran_env, only : int8, int16, int32, int64 implicit none integer(kind=int32) :: ival integer :: shift integer(kind=int32) :: oval integer(kind=int32),allocatable :: ivals(:) integer :: i integer(kind=int8) :: arr(2,2)=reshape([2,4,8,16],[2,2])Results:! basic usage write(*,*)shifta(100,3)
! loop through some interesting values shift=5
ivals=[ -1, -0, +0, +1, & & int(b"01010101010101010101010101010101"), & & int(b"10101010101010101010101010101010"), & & int(b"00000000000000000000000000011111") ]
! does your platform distinguish between +0 and -0? ! note the original leftmost bit is used to fill in the vacated bits
write(*,(/,"SHIFT = ",i0)) shift do i=1,size(ivals) ival=ivals(i) write(*,( "I = ",b32.32," == ",i0)) ival,ival oval=shifta(ival,shift) write(*,( "RESULT = ",b32.32," == ",i0)) oval,oval enddo ! elemental write(*,*)"characteristics of the result are the same as input" write(*,(*(g0,1x))) & & "kind=",kind(shifta(arr,3)), "shape=",shape(shifta(arr,3)), & & "size=",size(shifta(arr,3)) !, "rank=",rank(shifta(arr,3))
end program demo_shifta
> 12 > > SHIFT = 5 > I =<PHONE_NUMBER>1111111111111111111111 == -1 > RESULT =<PHONE_NUMBER>1111111111111111111111 == -1 > I =<PHONE_NUMBER>0000000000000000000000 == 0 > RESULT =<PHONE_NUMBER>0000000000000000000000 == 0 > I =<PHONE_NUMBER>0000000000000000000000 == 0 > RESULT =<PHONE_NUMBER>0000000000000000000000 == 0 > I =<PHONE_NUMBER>0000000000000000000001 == 1 > RESULT =<PHONE_NUMBER>0000000000000000000000 == 0 > I =<PHONE_NUMBER>0101010101010101010101 ==<PHONE_NUMBER> > RESULT =<PHONE_NUMBER>1010101010101010101010 == 44739242 > I =<PHONE_NUMBER>1010101010101010101010 == -1431655766 > RESULT =<PHONE_NUMBER>0101010101010101010101 == -44739243 > I =<PHONE_NUMBER>0000000000000000011111 == 31 > RESULT =<PHONE_NUMBER>0000000000000000000000 == 0 > characteristics of the result are the same as input > kind= 1 shape= 2 2 size= 4
Fortran 2008
SHIFTL(3), SHIFTR(3), ISHFT(3), ISHFTC(3)
fortran-lang intrinsic descriptions (license: MIT) @urbanjost
| Nemo Release 3.1 | shifta (3) | July 22, 2023 |


Three custom results are injected into the Place Predictions. Try searching for "International Airport" or "Domestic Airport" to see them in action.
Custom places appear with a label after them as required by the
Google Places API terms. This label can be
overridden by putting a custom_prediction_label
on your custom place results. The label can
also be styled via the .custom-prediction-label
class.
{{place | json}}


Welcome to the blog of Kim Hartley
One analogy of the differences between the two is by thinking of a house. HTML code is the how you structure and fill your website out. So the structure of the house is the HTML.
When you think about your house and what it is comprised of to make it your house. My house has 4 bedrooms, 1 office, a kitchen, a lounge and 2 bathrooms.
If you build a house, you start from the ground up. To simplify things and not go to into detail with things like windows, piping and cables etc. You would build the foundations,
build the frame of the house (obviously planned out where the rooms and sizes are) and then finish up the walls, roof etc.
HTML is very similar, except you'd start from top to bottom. You'd make the foundations of the page (the most basic would have HTML, body, heading and a paragraph code),
you would other code in to build it like a houses framework and then fill the page with the content you want to put (like finishing up the house).
We can also us the analogy of the house to think of and explain CSS. CSS is where you write the styling (like colors or positioning of objects) for the website.
So imagine your bedroom and think about where you've put your bed, shelves, drawers and so on. When you moved in and before you set up your room, it would for instance be a big pile of your stuff.
From that pile you'd sort everything out and set it up the way you want. With a website without CSS would have no color, no font styling and no positioning
(all font and objects would be on the left side). Like you set up your room, you use the CSS to sort of the contents of the page. You position where you want pictures or content to go, add color or new fonts to
the writing until everything looks good, sorted out and not bland.
Control flow is the order in which statements, instructions and functions are executed and evaluated. Loops are where the program will perform a set of instructions until a condition has been met. For example you could think about practicing basketball and say you want to work on your 3 point shot from a certain position on the court. You would take your position where you want to shoot from, you'd make the shot, see if it went in and then go to get the ball to do it again. So the flow would be, position, shoot and retrieve. You had decided before going that you'd make a hundred shots before you left. So you would shoot a hundred shots and then you could stop (ending the loop).
The DOM is Document Object Model. It is a data representation of the objects on a page and it looks like a family tree would. Your family tree say starts at your parents, then its you and your siblings and if then their children. The DOM would start at the top with HTML (parents) then it would show the elements, like the head or body of the page (siblings) and then the elements underneath like paragraphs (children). You can see the DOM on your browser, for example in chrome if you right click, click inspect then you can see and manipulate the DOM. You can also manipulate it from the code editor. From here you write in code to do whatever you are wanting to do. For instance, this sprint we used code to change the appearance of 4 dots written into the HTML code. We were able to reveal a hidden dot and change the colors.
An array is a type of a list, a special variable which can hold multiple values. For example the variable is cars and values would be types like BMW or Audi. So it'd look something like
cars = ['BMW', 'AUDI', 'TOYOTA']. These can be accessed by an index number, with programming the value always starts at 0. So BMW would be [0], AUDI [1] and TOYOTA [2].
Objects represent "things" which has properties. So for an objecy you also use cars and the properties would be of the car. It'd look something like cars = {type: 'BMW', made: 2020, color: 'Black'} and you can access it
like an array (index number) but with a key. For example you'd write car.color (to return black) or car['make'] (to return 2020).
A function simply put is a block of code which performs a particular task. This is useful as it allows a website to be able to do things from interactions. For example you have a calculator, you would write in the functions so it would operate correctly. Say you inputed 1*9 and hit =, the function would allow it to be proccessed and would return the answer of 9.


| Top |
The GSettingsBackend interface defines a generic interface for non-strictly-typed data that is stored in a hierarchy. To implement an alternative storage backend for GSettings, you need to implement the GSettingsBackend interface and then make it implement the extension point G_SETTINGS_BACKEND_EXTENSION_POINT_NAME.
The interface defines methods for reading and writing values, a method for determining if writing of certain values will fail (lockdown) and a change notification mechanism.
The semantics of the interface are very precisely defined and implementations must carefully adhere to the expectations of callers that are documented on each of the interface methods.
Some of the GSettingsBackend functions accept or return a GTree.
These trees always have strings as keys and GVariant as values.
g_settings_backend_create_tree()
is a convenience function to create
suitable trees.
The GSettingsBackend API is exported to allow third-party
implementations, but does not carry the same stability guarantees
as the public GIO API. For this reason, you have to define the
C preprocessor symbol G_SETTINGS_ENABLE_BACKEND
before including
gio/gsettingsbackend.h
.
GSettingsBackend *
g_settings_backend_get_default (void
);
Returns the default GSettingsBackend. It is possible to override
the default by setting the GSETTINGS_BACKEND
environment variable
to the name of a settings backend.
The user gets a reference to the backend.
Since 2.28
void g_settings_backend_changed (GSettingsBackend *backend
,const gchar *key
,gpointer origin_tag
);
Signals that a single key has possibly changed. Backend implementations should call this if a key has possibly changed its value.
key
must be a valid key (ie starting with a slash, not containing
'//', and not ending with a slash).
The implementation must call this function during any call to
g_settings_backend_write()
, before the call returns (except in the
case that no keys are actually changed and it cares to detect this
fact). It may not rely on the existence of a mainloop for
dispatching the signal later.
The implementation may call this function at any other time it likes
in response to other events (such as changes occurring outside of the
program). These calls may originate from a mainloop or may originate
in response to any other action (including from calls to
g_settings_backend_write()
).
In the case that this call is in response to a call to
g_settings_backend_write()
then origin_tag
must be set to the same
value that was passed to that call.
backend |
a GSettingsBackend implementation |
|
key |
the name of the key |
|
origin_tag |
the origin tag |
Since 2.26
void g_settings_backend_path_changed (GSettingsBackend *backend
,const gchar *path
,gpointer origin_tag
);
Signals that all keys below a given path may have possibly changed. Backend implementations should call this if an entire path of keys have possibly changed their values.
path
must be a valid path (ie starting and ending with a slash and
not containing '//').
The meaning of this signal is that any of the key which has a name
starting with path
may have changed.
The same rules for when notifications must occur apply as per
g_settings_backend_changed()
. This call might be an appropriate
reasponse to a 'reset' call but implementations are also free to
explicitly list the keys that were affected by that call if they can
easily do so.
For efficiency reasons, the implementation should strive for path
to
be as long as possible (ie: the longest common prefix of all of the
keys that were changed) but this is not strictly required. As an
example, if this function is called with the path of "/" then every
single key in the application will be notified of a possible change.
backend |
a GSettingsBackend implementation |
|
path |
the path containing the changes |
|
origin_tag |
the origin tag |
Since 2.26
void g_settings_backend_keys_changed (GSettingsBackend *backend
,const gchar *path
,gchar const * const *items
,gpointer origin_tag
);
Signals that a list of keys have possibly changed. Backend implementations should call this if keys have possibly changed their values.
path
must be a valid path (ie starting and ending with a slash and
not containing '//'). Each string in items
must form a valid key
name when path
is prefixed to it (ie: each item must not start or
end with '/' and must not contain '//').
The meaning of this signal is that any of the key names resulting
from the contatenation of path
with each item in items
may have
changed.
The same rules for when notifications must occur apply as per
g_settings_backend_changed()
. These two calls can be used
interchangeably if exactly one item has changed (although in that
case g_settings_backend_changed()
is definitely preferred).
For efficiency reasons, the implementation should strive for path
to
be as long as possible (ie: the longest common prefix of all of the
keys that were changed) but this is not strictly required.
backend |
a GSettingsBackend implementation |
|
path |
the path containing the changes |
|
items |
the |
[array zero-terminated=1] |
origin_tag |
the origin tag |
Since 2.26
void g_settings_backend_path_writable_changed (GSettingsBackend *backend
,const gchar *path
);
Signals that the writability of all keys below a given path may have changed.
Since GSettings performs no locking operations for itself, this call will always be made in response to external events.
Since 2.26
void g_settings_backend_writable_changed (GSettingsBackend *backend
,const gchar *key
);
Signals that the writability of a single key has possibly changed.
Since GSettings performs no locking operations for itself, this call will always be made in response to external events.
Since 2.26
void g_settings_backend_changed_tree (GSettingsBackend *backend
,GTree *tree
,gpointer origin_tag
);
This call is a convenience wrapper. It gets the list of changes from
tree
, computes the longest common prefix and calls
g_settings_backend_changed()
.
backend |
a GSettingsBackend implementation |
|
tree |
a GTree containing the changes |
|
origin_tag |
the origin tag |
Since 2.26
void g_settings_backend_flatten_tree (GTree *tree
,gchar **path
,const gchar ***keys
,GVariant ***values
);
Calculate the longest common prefix of all keys in a tree and write out an array of the key names relative to that prefix and, optionally, the value to store at each of those keys.
You must free the value returned in path
, keys
and values
using
g_free()
. You should not attempt to free or unref the contents of
keys
or values
.
Since 2.26
GSettingsBackend * g_keyfile_settings_backend_new (const gchar *filename
,const gchar *root_path
,const gchar *root_group
);
Creates a keyfile-backed GSettingsBackend.
The filename of the keyfile to use is given by filename
.
All settings read to or written from the backend must fall under the
path given in root_path
(which must start and end with a slash and
not contain two consecutive slashes). root_path
may be "/".
If root_group
is non-NULL
then it specifies the name of the keyfile
group used for keys that are written directly below root_path
. For
example, if root_path
is "/apps/example/" and root_group
is
"toplevel", then settings the key "/apps/example/enabled" to a value
of TRUE
will cause the following to appear in the keyfile:
1 2 |
[toplevel] enabled=true |
If root_group
is NULL
then it is not permitted to store keys
directly below the root_path
.
For keys not stored directly below root_path
(ie: in a sub-path),
the name of the subpath (with the final slash stripped) is used as
the name of the keyfile group. To continue the example, if
"/apps/example/profiles/default/font-size" were set to
12 then the following would appear in the keyfile:
1 2 |
[profiles/default] font-size=12 |
The backend will refuse writes (and return writability as being
FALSE
) for keys outside of root_path
and, in the event that
root_group
is NULL
, also for keys directly under root_path
.
Writes will also be refused if the backend detects that it has the
inability to rewrite the keyfile (ie: the containing directory is not
writable).
There is no checking done for your key namespace clashing with the syntax of the key file format. For example, if you have '[' or ']' characters in your path names or '=' in your key names you may be in trouble.
filename |
the filename of the keyfile |
|
root_path |
the path under which all settings keys appear |
|
root_group |
the group name corresponding to
|
[allow-none] |
GSettingsBackend *
g_memory_settings_backend_new (void
);
Creates a memory-backed GSettingsBackend.
This backend allows changes to settings, but does not write them to any backing storage, so the next time you run your application, the memory backend will start out with the default values again.
Since 2.28
GSettingsBackend *
g_null_settings_backend_new (void
);
Creates a readonly GSettingsBackend.
This backend does not allow changes to settings, so all settings will always have their default values.
Since 2.28
typedef struct _GSettingsBackend GSettingsBackend;
An implementation of a settings storage repository.
struct GSettingsBackendClass { GObjectClass parent_class; GVariant * (*read) (GSettingsBackend *backend, const gchar *key, const GVariantType *expected_type, gboolean default_value); gboolean (*get_writable) (GSettingsBackend *backend, const gchar *key); gboolean (*write) (GSettingsBackend *backend, const gchar *key, GVariant *value, gpointer origin_tag); gboolean (*write_tree) (GSettingsBackend *backend, GTree *tree, gpointer origin_tag); void (*reset) (GSettingsBackend *backend, const gchar *key, gpointer origin_tag); void (*subscribe) (GSettingsBackend *backend, const gchar *name); void (*unsubscribe) (GSettingsBackend *backend, const gchar *name); void (*sync) (GSettingsBackend *backend); GPermission * (*get_permission) (GSettingsBackend *backend, const gchar *path); GVariant * (*read_user_value) (GSettingsBackend *backend, const gchar *key, const GVariantType *expected_type); gpointer padding[23]; };
#define G_SETTINGS_BACKEND_EXTENSION_POINT_NAME "gsettings-backend"
Extension point for GSettingsBackend functionality.


Ansar Al Madeena Technical Contracting is a MEP based contracting company that majorly deals with the mechanical works in this field. AMTCO is now recognized as the leading sub-contractor in this field in UAE. The scope of activities are majorly all the mechanical equipment installation, chilled water piping, ducting, cladding, steel structure fabrication with installation and welding, pressure testing and flushing of system.
The company offers a 24/7 services according to the client demands. AMTCO is a fully registered and approved company according to the laws of UAE. Due to its round capability and high standards of working, the company is involved in many notable projects all around UAE.
We have accomplished the projects as sub-contractor to many reputed and multi-national companies in UAE.
If you're wondering why do you have to choose us over other companies around. well, we are well known for providing quality construction solutions for our clients, that is well proven from our experience, having been in the business for over 12 years. We build faster through clear communication and interaction and therefore drive quality results.
AMTCO prides themselves with having a strong dedication to the principle that a quality product is its own best form of advertising. Their employees are the best craftsman in the area. Quality construction continues after the close of the project.
At AMTCO, we take an all-inclusive approach to managing scheduling, estimating, budget control, value engineering, sub-contractor bid solicitation, on-site supervision, quality control, cost control, safety monitoring, communications services, total project management and a commitment to delivering expert approach and exceptional value.
At MTCO, We believe in working with passion in all that we set out to do. We are passionate about our work, our clients, and our industry, about delivering a level of service that reaches far beyond the expectation of the traditional. We care about our people: Our clients, our workers and our vendors. It is this passion that drives our business, it allows us to deliver a quality of service that is unmatched in our industry and area.
At AMTCO, we believe that working successfully means working together and that means fostering team work among our staff, taking a genuinely collaborative approach with our clients, building positive relationships with partners and sub-contractors and ultimately, contributing to the communities within which we build – partnership is at the heart of everything we do.
AMTCO will ALWAYS be our "GO TO" company for HVAC needs. Their professionalism and friendly demeanor are second to none. The entire staff at AMTCO are AWESOME and we are so glad to have worked with them. We highly highly recommend them if you want quality services for you HVAC construction. Thank you AMTCO!!
Fujairah City Center
The customer service with this company has been nothing but top notch. They always return phone calls, follow up on email requests and arrive at scheduled appts. To me this is key, as we all are busy and time is money. The technicians are courteous, friendly and seem to know what they are doing. Overall, they delievered quality services.
Swan Towers Ajman
We have been using Ansar Al Madeena Tech. Cont. Co for a few years now and really appreciate their professional, competent and cordial staff. They are always on time and do their work without any fuss. We highly recommend them for any of your HVAC service needs if you desire to have quality services delivered
Al Habtoor City


Status
Jean Tessier API
Development Status
as of November 06, 2001
Feature
Status
Documentation
Not started


DAVNISH SINGH
Davnish is a Founder and CEO of ConfessionWeb, which he founded in 2018. Davnish is responsible for setting the overall direction and product strategy for the company. He leads the design of CW's service and development of its core technology and infrastructure.
Davnish Singh is currently pursuing his undergraduate studies in Computer Science from Kwantlen Polytechnic University. He was also an undergraduate scholar at Stanford University worked on research papers on Artificial Intelligence and Machine Learning under Neural Networks in computer vision and pattern recognition. As a machine learning enthusiast, he always believed that by applying ML in the every field one can make a change and automate the regular tasks on hand to focus on other ones as well. In addition to his passion for Machine Learning and software technologies, he has got a strong passion for algorithms because he thinks that problems need to be solved instead of only being discovered.
He built this platform purely with one mission - "to let users confess things about their lives, connect and help them through this platform".
To know more about him, visit his website www.davnishsingh.me.
HIRDAYPAL SINGH
Hirdaypal Singh is a Co-Founder & CTO of ConfessionWeb.
Hirday is pursuing his undergraduate studies in Computer Science in india.
He is the most dynamic person in our team with numerous interets like Web Development. He started as a CTO of ConfessionWeb in 2018 and happen to be a top priority to handle such big responsibilities as a CTO of company.
His management and technological skills will help the company in a long run to deliver the best products and features to our users on time. He will be managing and mentoring our Front-End engineers in the future to deliver the latest features and products to our users.
To know more about him, you can connect to him on LinkedIn and Facebook.
RAJAT GUPTA
Rajat Gupta is a Co-Founder & Chief Product Officer of ConfessionWeb.
Rajat will be leading ConfessionWeb's Product Management, Design, and Marketing functions globally. He will be responsible for the core products and features that shape the social experience for everyone who uses ConfessionWeb. Rajat joined ConfessionWeb in 2018.
Rajat is a problem solver & enthusiastic programmer with 2+ years of experience solving complex business & user problems through technology. He enjoy getting engaged in projects requiring innovative & creative solutions. He has extensive experience in building Mobile(Android and iOS) and Web-based applications, & implementing Server side coding involving databases & APIs using Machine learning and Artificial intelligence concepts.
To know more about him, you can connect to him on LinkedIn and follow his work on Github.
SUKRITI
Sukriti is a Co-Founder & Vice President of Engineering(Core Tech - Growth) of ConfessionWeb. She will be leading the overall simulation and product management in a most efficient way to deliver the products to our users. She is responsible for ensuring that the product vision is realized through excellence in execution.
Sukriti will be leading the ideation, technical development, and launch of innovative products. With her incomparable technical skills, she integrate usability studies, research and market analysis into product requirements to enhance user satisfaction. She is responsible for co-developing the technical strategy and for developing and maintaining a technical roadmap that will continue to innovate from a technical standpoint. Sukriti joined ConfessionWeb in 2018. She will be responsible for orchestrating the various activities associated with ensuring that a product is delivered that meets users' needs. She is pursuing her undergraduate studies in Computer Science from Kwantlen Polytechnic University.
To know more about her, you can follow her work on Github.


Grid Structure
Our theme is based on UiKit and you can get the Documentation on UiKit website.
Width
Define the width of elements for different viewport sizes.
UIkit's width component is often used in combination with grids to split content into responsive columns. You can apply fractions, automatic width or expand units to fill the remaining space and combine these modes.
Usage
Add one of the .uk-width-*
classes to an element to determine its size. Typically, you
would use a grid from the Grid component and its child elements to create
the units.
| Class | Description |
|---|---|
.uk-width-1-1 |
Fills 100% of the available width. |
.uk-width-1-2 |
The element takes up halves of its parent container. |
.uk-width-1-3 to .uk-width-2-3 |
The element takes up thirds of its parent container. |
.uk-width-1-4 to .uk-width-3-4 |
The element takes up fourths of its parent container. |
.uk-width-1-5 to .uk-width-4-5 |
The element takes up fifths of its parent container. |
.uk-width-1-6 to .uk-width-5-6 |
The element takes up sixths of its parent container. |

-
1-31-31-31-21-21-43-4
-

1-3

1-3

1-3

1-2

1-2

1-4

3-4

Auto & expand
The width component provides additional modifiers to give you more flexibility in the distribution of items.
| Class | Description |
|---|---|
.uk-width-auto |
The item expands only to the width of its own content. |
.uk-width-expand |
The item expands to fill up the remaining space of the grid container. |

-
Auto
-

Auto

Expand

Equal child widths
To create a grid whose child elements' widths are evenly split, you don't have to apply the same
class to each list item within the grid. Just add one of the .uk-child-width-*
classes
to the grid itself.
| Class | Description |
|---|---|
.uk-child-width-1-2 |
All elements take up half of their parent container. |
.uk-child-width-1-3 |
All elements take up a third of their parent container. |
.uk-child-width-1-4 |
All elements take up a fourth of their parent container. |
.uk-child-width-1-5 |
All elements take up a fifth of their parent container. |
.uk-child-width-1-6 |
All elements take up a sixth of their parent container. |
.uk-child-width-auto |
Divides the grid into equal units depending on the content size. |
.uk-child-width-expand |
Divides the grid into equal units depending on the available space. |

...

-
ItemItemItemItemItem
-

Item

Item

Item

Item

Item

Items that use width classes with fractions will break into a new row, if they no longer fit their container's width. When using one of the expand classes, however, the space will be evenly distributed among items that always stay in the same row.

...

-

Item

Item

Item

Item

Item

Fixed width
In addition to the calculated width classes, you can also add one of the following classes, which apply fixed widths.
| Class | Description |
|---|---|
.uk-width-small |
Applies a fixed width of 150px. |
.uk-width-medium |
Applies a fixed width of 300px. |
.uk-width-large |
Applies a fixed width of 450px. |
.uk-width-xlarge |
Applies a fixed width of 600px. |
.uk-width-xxlarge |
Applies a fixed width of 750px. |

-
SmallMediumLargeX LargeXX Large
-

Small

Medium

Large

X Large

XX Large

Mixing widths
You can also combine .uk-child-width-*
classes with .uk-width-*
classes
for individual items. That way it is possible, for example, to create a grid with one item that
has a specific width and all other items expanding to fill the remaining space.

...

-

Expand

1-3

Expand

Expand

Responsive width
UIkit provides a number of responsive widths classes. Basically they work just like the usual width classes, except that they have suffixes that represent the breakpoint from which they come to effect. These classes can be combined with the Visibility component. This is great to adjust your layout and content for different device sizes.
| Class | Description |
|---|---|
.uk-width-* .uk-child-width-* |
Affects all device widths, grid columns stay side by side. |
.uk-width-*@s .uk-child-width-*@s |
Affects device widths of 640px and larger. Grid columns will stack on smaller sizes. |
.uk-width-*@m .uk-child-width-*@m |
Affects device widths of 960px and larger. Grid columns will stack on smaller sizes. |
.uk-width-*@l .uk-child-width-*@l |
Affects device widths of 1200px and larger. Grid columns will stack on smaller sizes. |
.uk-width-@xl .uk-child-width-*@xl |
Affects device widths of 1600px and larger. Grid columns will stack on smaller sizes. |
-
1-2@m1-4@m1-4@m1-5@m
hidden@l1-5@m
1-3@l3-5@m
2-3@lauto@m
visible@l1-3@m -

1-2@m

1-4@m

1-4@m

1-5@m
hidden@l

1-5@m
1-3@l

3-5@m
2-3@l

auto@m
visible@l

1-3@m

expand@m


--- layout: page title: Topics background: '/img/fig_cap_all_comparison-eps-converted-to.pdf' ---
The following pages are collections of posts from this blog, external links, and academic papers that are related by some common theme. The materials are not intended to be exhaustive, and will evolve over time as I add more references and links.


SIGN UP HERE
Username
Last Name
Email
Password
Confirm Password
SIGNUP
I accept
Terms and Conditions


{% extends 'template.html' %} {% block content %}
Posted by {{post.author}} {{post.published|timesince}} ago
upvotes: {{post.upvotes}}
downvotes: {{post.downvotes}}
total: {{post.netVotes}}
{{comment.author}}
{{comment.content}}
+{{comment.upvotes}}
-{{comment.downvotes}}


Temporal Identities
May 2010
NKG presented a May 2010 exhibition titled Temporal Identities. This show included the works of four active Massachusetts artists: Cathy McLaurin, Louise Weinberg, Helga Felleisen, and Kelly Anona Kerrigan. Their work conceptually examines the hidden, inconstant or nonconcrete nature of identity. With elements of painting, drawing and installation in play, these artists challenge the temporal quality of sense of self.
This exhibition was available May 5 - 28, 2010 with opening reception May 7, 5 - 8 PM
Artists
Helga Felleisen
Kelly Anona Kerrigan
Cathy McLaurin
Louise Weinberg


{% extends 'pageApp/base.html' %} {% load static %} {% block style %} {% endblock style %} {% block header%}
Audre Lorde
The master's tools will never dismantle the master's house.
When I dare to be powerful, to use my strength in the service of my vision, then it becomes less and less important whether I am afraid.
It is not our differences that divide us. It is our inability to recognize, accept, and celebrate those differences.
When we speak we are afraid our words will not be heard or welcomed. But when we are silent, we are still afraid. So it is better to speak.
{% endblock section %} {% block article%} {% endblock article%}


This section specifies the attributes and rules for the following list of Financial module profiles.
| Profile description | calcrule_id |
|---|---|
| Do nothing (pass losses through) | 100 |
| deductible and limit | 1 |
| deductible with attachment, limit and share | 2 |
| franchise deductible and limit | 3 |
| deductible % TIV and limit | 4 |
| deductible and limit % loss | 5 |
| deductible % TIV | 6 |
| deductible, minimum and maximum deductible, with limit | 7 |
| deductible and minimum deductible, with limit | 8 |
| limit with deductible % limit | 9 |
| deductible and maximum deductible | 10 |
| deductible and minimum deductible | 11 |
| deductible | 12 |
| deductible, minimum and maximum deductible | 13 |
| limit only | 14 |
| deductible and limit % loss | 15 |
| deductible % loss | 16 |
| deductible % loss with attachment, limit and share | 17 |
| deductible % tiv with attachment, limit and share | 18 |
| deductible % loss with min and/or max deductible | 19 |
| reverse franchise deductible | 20 |
| deductible % tiv with min and max deductible | 21 |
| reinsurance % ceded, limit and % placed | 22 |
| reinsurance limit and % placed | 23 |
| reinsurance excess terms | 24 |
| reinsurance proportional terms | 25 |
| deductible % loss with min and/or max deductible and limit | 26 |
| % tiv trigger and % tiv step payout with limit | 27 |
| % tiv trigger and % loss step payout | 28 |
| % tiv trigger and % tiv step payout | 29 |
| % tiv trigger and % limit step payout | 30 |
| % tiv trigger and monetary amount step payout | 31 |
| monetary amount trigger and % loss step payout with limit | 32 |
| deductible % loss with limit | 33 |
| deductible with attachment and share | 34 |
| deductible % loss with min and/or max deductible and limit % loss | 35 |
| deductible with min and/or max deductible and limit % loss | 36 |
| calcrule_id | d1 | d2 | d3 | a1 | l1 | sh1 | sh2 | sh3 | st | ts | te | ps | pe | l2 | sc1 | sc2 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 100 | ||||||||||||||||
| 1 | x | x | ||||||||||||||
| 2 | x | x | x | x | ||||||||||||
| 3 | x | x | ||||||||||||||
| 4 | x | x | ||||||||||||||
| 5 | x | x | ||||||||||||||
| 6 | x | |||||||||||||||
| 7 | x | x | x | x | ||||||||||||
| 8 | x | x | x | |||||||||||||
| 9 | x | x | ||||||||||||||
| 10 | x | x | ||||||||||||||
| 11 | x | x | ||||||||||||||
| 12 | x | |||||||||||||||
| 13 | x | x | x | |||||||||||||
| 14 | x | |||||||||||||||
| 15 | x | x | ||||||||||||||
| 16 | x | |||||||||||||||
| 17 | x | x | x | x | ||||||||||||
| 18 | x | x | x | x | ||||||||||||
| 19 | x | x | x | |||||||||||||
| 20 | x | |||||||||||||||
| 21 | x | x | x | |||||||||||||
| 22 | x | x | x | x | ||||||||||||
| 23 | x | x | x | |||||||||||||
| 24 | x | x | x | x | x | |||||||||||
| 25 | x | x | x | |||||||||||||
| 26 | x | x | x | x | ||||||||||||
| 27 | x | x | x | x | x | x | x | x | x | |||||||
| 28 | x | x | x | x | x | x | x | x | ||||||||
| 29 | x | x | x | x | x | x | x | x | ||||||||
| 30 | x | x | x | x | x | x | x | x | x | |||||||
| 31 | x | x | x | x | x | x | x | x | ||||||||
| 32 | x | x | x | x | x | x | x | |||||||||
| 33 | x | x | ||||||||||||||
| 34 | x | x | x | |||||||||||||
| 35 | x | x | x | x | ||||||||||||
| 36 | x | x | x | x |
The fields with an x are those which are required by the profile. The full names of the fields are as follows;
| Short name | Profile field name |
|---|---|
| d1 | deductible_1 |
| d2 | deductible_2 |
| d3 | deductible_3 |
| a1 | attachment_1 |
| l1 | limit_1 |
| sh1 | share_1 |
| sh2 | share_2 |
| sh3 | share_3 |
| st | step_id |
| ts | trigger_start |
| te | trigger_end |
| ps | payout_start |
| pe | payout_end |
| l2 | limit_2 |
| sc1 | scale_1 |
| sc2 | scale_2 |
An allocation rule can be assigned to each call of fmcalc, which determines whether calculated losses should be back-allocated to the contributing items, and if so how. This is specified via the command line parameter -a.
The choices are as follows;
| Allocrule description | allocrule_id |
|---|---|
| Don't back-allocate losses (default if no parameter supplied) | 0 |
| Back allocate losses to items in proportion to input loss | 1 |
| Back-allocate losses to items in proportion to prior level loss | 2 |
| Back-allocate losses to items in proportion to prior level loss (reinsurance) | 3 |
Often there are more than one hierarchal levels with deductibles, and there is a choice of methods of accumulation of deductibles through the hierarchy. Whenever a rule with a deductible is used in the loss calculation then it is accumulated through the calculation in an effective_deductible variable. The effective deductible is the smaller of the deductible amount and the loss.
All deductibles amounts calculated from the deductible_1 field are simply additive through the hierarchy.
Ay any level, the user can specify a calcrule using a minimum and/or maximum deductible which changes the way that effective deductibles are accumulated.
For a minimum deductible specified in calcrules using the deductible_2 field, the calculation increases the effective_deductible carried forward from the previous levels up to the minimum deductible if it is smaller.
For a maximum deductible specified in calcrules using the deductible_3 field, the calculation decreases the effective_deductible carried forward from the previous levels down to the maximum deductible if it is larger.
Loss adjustments due to minimum and maximum deductibles may lead to breaching or falling short of prior level limits. For instance, an increase in loss due a policy maximum deductible being applied can lead to a breach of site limit that applied at the prior calculation level. Conversely, a decrease in loss due to policy minimum deductible can leave the loss falling short of a site limit applied at the prior calculation level. In these situations the prior level limits are carried through and reapplied in all calcrules that have minimum and/or maximum deductibles.
We introduce the following variables;
The over and under limit variables are initialised when there exist prior level limits. The possible cases are;
| Case | Under limit | Over limit | Meaning |
|---|---|---|---|
| 1 | 0 | 0 | All prior level losses are exactly at their limits |
| 2 | 0 | >0 | Some prior level losses are over limit and none are under limit |
| 3 | >0 | 0 | Some prior level losses are under limit and none are over limit |
| 4 | >0 | >0 | Some prior level losses are over limit and some are under limit |
When the loss delta is positive;
When the loss delta is negative;
Current calculation level limits may also apply and these are used to update the over limit and under limit measures to carry through to the next level.
In the following notation;
| Attributes | Example |
|---|---|
| policytc_id | 1 |
| calcrule_id | 1 |
| deductible_1 | 50000 |
| limit_1 | 900000 |
loss = x.loss - deductible_1;
if (loss < 0) loss = 0;
if (loss > limit_1) loss = limit_1;
| Attributes | Example |
|---|---|
| policytc_id | 1 |
| calcrule_id | 2 |
| deductible_1 | 70000 |
| attachment_1 | 0 |
| limit_1 | 1000000 |
| share_1 | 0.1 |
loss = x.loss - deductible_1
if (loss < 0) loss = 0;
if (loss > (attachment_1 + limit_1)) loss = limit_1;
else loss = loss - attachment_1;
if (loss < 0) loss = 0;
loss = loss * share_1;
| Attributes | Example |
|---|---|
| policytc_id | 1 |
| calcrule_id | 3 |
| deductible_1 | 100000 |
| limit_1 | 1000000 |
if (x.loss < deductible_1) loss = 0;
else loss = x.loss;
if (loss > limit_1) loss = limit_1;
| Attributes | Example |
|---|---|
| policytc_id | 1 |
| calcrule_id | 5 |
| deductible_1 | 0.05 |
| limit_1 | 0.3 |
loss = x.loss - (x.loss * deductible_1);
if (loss > (x.loss * limit_1)) loss = x.loss * lim;
| Attributes | Example |
|---|---|
| policytc_id | 1 |
| calcrule_id | 9 |
| deductible_1 | 0.05 |
| limit_1 | 100000 |
loss = x.loss - (deductible_1 * limit_1);
if (loss < 0) loss = 0;
if (loss > limit_1) loss = limit_1;
If the effective deductible carried forward from the previous level exceeds the maximum deductible, the effective deductible is decreased to the maximum deductible value
| Attributes | Example |
|---|---|
| policytc_id | 1 |
| calcrule_id | 10 |
| deductible_3 | 40000 |
if (x.effective_deductible > deductible_3) {
loss = x.loss + x.effective_deductible - deductible_3;
if (loss < 0) loss = 0;
}
else {
loss = x.loss;
}
If the effective deductible carried forward from the previous level is less than the minimum deductible, the deductible is increased to the total loss or the minimum deductible value, whichever is greater.
| Attributes | Example |
|---|---|
| policytc_id | 1 |
| calcrule_id | 11 |
| deductible_2 | 70000 |
if (x.effective_deductible < deductible_2) {
loss = x.loss + x.effective_deductible - deductible_2;
if (loss < 0) loss = 0;
}
else {
loss = x.loss;
}
| Attributes | Example |
|---|---|
| policytc_id | 1 |
| calcrule_id | 12 |
| deductible_1 | 100000 |
loss = x.loss - deductible_1;
if (loss < 0) loss = 0;
| Attributes | Example |
|---|---|
| policytc_id | 1 |
| calcrule_id | 14 |
| limit | 100000 |
loss = x.loss;
if (loss > limit_1) loss = limit_1;
| Attributes | Example |
|---|---|
| policytc_id | 1 |
| calcrule_id | 15 |
| limit_1 | 0.3 |
loss = x.loss * limit_1;
| Attributes | Example |
|---|---|
| policytc_id | 1 |
| calcrule_id | 16 |
| deductible_1 | 0.05 |
loss = x.loss - (x.loss * deductible_1);
if (loss < 0) loss = 0;


Configuring for the experiment
If you already answered the first form, your Participant ID will be the email address you entered in the form. We will not share the address, but if you prefer to use a different ID, please contact us (jpimentel@ic.uff.br).
Now you need to install and configure Julynter for the experiment. Please open a terminal and follow these steps:
-
Install Julynter
pip install julynter
-
Start the experiment
julynter experiment start
It will ask you to authorize the collection of some usage data for the experiment. The more data you allow us to collect, the better our capacity to contextualize the experimental trial.
-
Run Jupyter Lab and Julynter
Now, you can open Jupyter Lab and use Julynter for linting your notebooks in real-time. If you have NodeJS, you can run Jupyter Lab normally (
jupyter lab
), and it will ask you to rebuild to install the Julynter extension. Otherwise, use the precompiled version of Jupyter Lab with Julynter installed:julynter lab
-
Check the installation
Julynter appears on the left panel of Jupyter Lab as a circle with a correct sign (). Open it after opening the notebook to start linting.
Please, check if it is running in the experiment mode by verifying the existence of an "E" in the top right corner of Julynter:
Please, use Julynter during the development of your next notebooks. You may use it while adding new code to existing notebooks or creating new notebooks. Note, however, that most linting occurs when cells are executed. Thus, if you use it with an existing notebook, you need to re-execute its cells. During the experiment, you may work on the notebooks as you usually do (e.g., creating notebooks, adding, editing, and removing cells, executing them). You may apply the linting suggestions as well.
If you find a linting suggestion useful, please consider clicking in the plus icon that appears when you hover it. Otherwise, please consider clicking in the minus icon. You may also click in the dialog icon to send us a report.
If you just answered the form, we will contact you back in a week to ask about your experience with Julynter. Feel free to contact us at any time.
If you do not have a notebook project to work on the following days, but still want to participate in this experiment, we can provide suggestions.


Lifeline For Ngele In AFCON Qualifiers!
by Soccer LadumaMogakolodi ‘Tsotso’ Ngele received a lifeline with a rare appearance on the field in the Africa Cup of Nations qualifiers.
Ngele, who joined Black Leopards this season after parting ways with Mamelodi Sundowns, has struggled for game-time at the Limpopo outfit.
Read – Sobhi Warns SA: ‘Let’s Not Forget We Scored Six…’
The 29-year-old has made only one appearance for Lidoda Duvha this season under the team’s former coach Lionel Soccoia.
Despite his lack of game-time, the attacking midfielder was called up for the Botswana senior national team’s AFCON qualifiers.
Read: Manyisa's Long-Term Sundowns Future Up In The Air?
Against Algeria on Monday night, Ngele almost scored when he was given a run in coach Adel Amrouche’s team at Botswana National Stadium.
The former Platinum Stars and SuperSport United player will hope to have done enough to impress coach Luc Eymael at Leopards on his return to the club after the FIFA international break.


Francais / Legal / About Us / Contact
Cart
Locations
Wishlist
Account
The App
Dashboard
How To Play
FAQ
Don Norman
PLAYERS
CLUBHOUSE
MAILBOX
HATEFUL EIGHT
Don Norman
EST. 2014
Square One
POST TO FACEBOOK
CELEBRATE
TRASH TALK
+
Dale Port
Hateful Eight
2014/03/05 - 2014/09/05
Stats
Current Rank
Total Spend
In Store Purchases
Online Purchases
Trophy Case
Top Riser
MVP
Finger Cookin'
x3
Home Field
x1
Your reward for scorching up the most places in the rankings.
You are a legend for bringing in the most earn to your team.
If I can't cook, I can sure as heck click a mean delivery.
Boston Pizza is my stadium and I am it's groundskeeper.
Top Stinker
LVP
Not sure how you still have friends.
Social Star
The most communicative communicator of all.
It's not too late to make a comeback.
x2
Previous Seasons
Please make a selection:
GO
2nd out of 8
6
$180.00
3
TEAM AVG
TEAM AVG
4.2
1.5


Natalie Ann Evans,
Childbirth Educator & Birth Doula
natalieannevans [at] gmail [dot] com • (773) 510–6230
Home
Childbirth Education
Doula Services
About Natalie
FAQs
Links
“Restoring women’s confidence, strength and joy in childbearing”
—ALACE motto


Please Note:
This theme requires a theming engine to work. Some of these theming engines include SnowBoard, iThemer and Anemone. Felicity Pro has been specifically built to be used with SnowBoard, but any of the above should work. This theme supports theming Settings App Icons. For this to work, you will need to install SnowBoard Settings Icons Extension from this repo: https://sparkdev.me Felicity Pro takes everything that was great about Felicity and pushes it further. With Felicity Pro, there is an all new redesign with deeper shadows and sharper glyphs. Many of the gradients and colors have also been improved for an all-round improved and more premium look and feel. Felicity Pro supports 700 icons. This is a number that will only grow with future releases. There is also a total of 19 alternate icons at launch and you can also expect this number to grow. Felicity Pro takes full use of your display by assigning P3 colour to each and every icon. This provides for a much more colourful experience. Every icon has been made with great care and attention to detail to ensure that all your icons have a uniform appearance. Felicity Pro has 3 different Alt Icon folders accessible through your Theming engine. These 3 folders have many different alt icon options so you can fully customize your icons. Some of these alt icons include different styled wallet icons, and also iOS 9/10 iTunes & AppStore Icons. First (and most obvious), Felicity Pro supports many more icons. A total of 700 (reg felicity is around 250). All new redesign. Every single icon has been completely redone with deeper shadows and sharper glyphs. I certainly prefer this new redesign, and i am sure you will too! Future updates. More and more updates will be coming to Felicity Pro in the future with all new content. About
How is this better than Felicity?
- This update add's 200 user requested icons! This takes the total to 700 icons. Amazing!
Enables P3 colour gamut across every single icon.
| Version | 2.0 |
| Updated | June 14, 2020 |
| Restriction(s) | Free |
| iOS Version(s) | 10.0 or later |