In this project, you will use the tools you learned about in the lesson to identify lane lines on the road. You can develop your pipeline on a series of individual images, and later apply the result to a video stream (really just a series of images). Check out the video clip "raw-lines-example.mp4" (also contained in this repository) to see what the output should look like after using the helper functions below.
Once you have a result that looks roughly like "raw-lines-example.mp4", you'll need to get creative and try to average and/or extrapolate the line segments you've detected to map out the full extent of the lane lines. You can see an example of the result you're going for in the video "P1_example.mp4". Ultimately, you would like to draw just one line for the left side of the lane, and one for the right.
In addition to implementing code, there is a brief writeup to complete. The writeup should be completed in a separate file, which can be either a markdown file or a pdf document. There is a write up template that can be used to guide the writing process. Completing both the code in the Ipython notebook and the writeup template will cover all of the rubric points for this project.
Let's have a look at our first image called 'test_images/solidWhiteRight.jpg'. Run the 2 cells below (hit Shift-Enter or the "play" button above) to display the image.
Note: If, at any point, you encounter frozen display windows or other confounding issues, you can always start again with a clean slate by going to the "Kernel" menu above and selecting "Restart & Clear Output".
The tools you have are color selection, region of interest selection, grayscaling, Gaussian smoothing, Canny Edge Detection and Hough Tranform line detection. You are also free to explore and try other techniques that were not presented in the lesson. Your goal is piece together a pipeline to detect the line segments in the image, then average/extrapolate them and draw them onto the image for display (as below). Once you have a working pipeline, try it out on the video stream below.
Run the cell below to import some packages. If you get an import error
for a package you've already installed, try changing your kernel (select the Kernel menu above --> Change Kernel). Still have problems? Try relaunching Jupyter Notebook from the terminal prompt. Also, see this forum post for more troubleshooting tips.
#importing some useful packages
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import numpy as np
import cv2
%matplotlib inline
#reading in an image
image = mpimg.imread('test_images/solidWhiteRight.jpg')
#printing out some stats and plotting
print('This image is:', type(image), 'with dimensions:', image.shape)
plt.imshow(image) # if you wanted to show a single color channel image called 'gray', for example, call as plt.imshow(gray, cmap='gray')
Some OpenCV functions (beyond those introduced in the lesson) that might be useful for this project are:
cv2.inRange()
for color selection
cv2.fillPoly()
for regions selection
cv2.line()
to draw lines on an image given endpoints
cv2.addWeighted()
to coadd / overlay two images
cv2.cvtColor()
to grayscale or change color
cv2.imwrite()
to output images to file
cv2.bitwise_and()
to apply a mask to an image
Check out the OpenCV documentation to learn about these and discover even more awesome functionality!
Below are some helper functions to help get you started. They should look familiar from the lesson!
import math
from sklearn.cluster import AgglomerativeClustering
from scipy import stats
import queue
def grayscale(img):
"""Applies the Grayscale transform
This will return an image with only one color channel
but NOTE: to see the returned image as grayscale
(assuming your grayscaled image is called 'gray')
you should call plt.imshow(gray, cmap='gray')"""
return cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
# Or use BGR2GRAY if you read an image with cv2.imread()
# return cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
def canny(img, low_threshold, high_threshold):
"""Applies the Canny transform"""
return cv2.Canny(img, low_threshold, high_threshold)
def gaussian_blur(img, kernel_size):
"""Applies a Gaussian Noise kernel"""
return cv2.GaussianBlur(img, (kernel_size, kernel_size), 0)
def region_of_interest(img, vertices):
"""
Applies an image mask.
Only keeps the region of the image defined by the polygon
formed from `vertices`. The rest of the image is set to black.
"""
#defining a blank mask to start with
mask = np.zeros_like(img)
#defining a 3 channel or 1 channel color to fill the mask with depending on the input image
if len(img.shape) > 2:
channel_count = img.shape[2] # i.e. 3 or 4 depending on your image
ignore_mask_color = (255,) * channel_count
else:
ignore_mask_color = 255
#filling pixels inside the polygon defined by "vertices" with the fill color
cv2.fillPoly(mask, vertices, ignore_mask_color)
#returning the image only where mask pixels are nonzero
masked_image = cv2.bitwise_and(img, mask)
return masked_image
previous_lines = ()
def draw_lines(img, lines, color=[255, 0, 0], thickness=10):
"""
NOTE: this is the function you might want to use as a starting point once you want to
average/extrapolate the line segments you detect to map out the full
extent of the lane (going from the result shown in raw-lines-example.mp4
to that shown in P1_example.mp4).
Think about things like separating line segments by their
slope ((y2-y1)/(x2-x1)) to decide which segments are part of the left
line vs. the right line. Then, you can average the position of each of
the lines and extrapolate to the top and bottom of the lane.
This function draws `lines` with `color` and `thickness`.
Lines are drawn on the image inplace (mutates the image).
If you want to make the lines semi-transparent, think about combining
this function with the weighted_img() function below
"""
left_lines = []
right_lines = []
epsilon = 1e-8 # avoid division by zero
def slope(segment):
x1, y1, x2, y2 = segment
return (y2 - y1) / (x2 - x1 + epsilon)
def average_slope(line):
slopes = [slope(segment) for segment in line]
return np.mean(slopes)
slopes = [average_slope(line) for line in lines]
"""
# use clustering to find slope groups
# this approach tended to find false groupings, and did not work as well as a simple
# positive/negative slope check
cluster_model = AgglomerativeClustering(n_clusters=2)
slopes_with_padding = [list(item) for item in zip(slopes, np.zeros_like(slopes))]
# group_labels contains 0 or 1 for the indexes of each line
group_labels = cluster_model.fit_predict(slopes_with_padding)
"""
# I experimented with weighting the lines by length, but the result wasn't that great
def length(segment):
x1, y1, x2, y2 = segment
return np.sqrt(np.square(x2 - x1) + np.square(y2 - y1))
def line_length(line):
lengths = [length(segment) for segment in line]
return np.sum(lengths)
lengths = [line_length(line) for line in lines]
combined = [{'length': lengths[i], 'slope': slopes[i], 'line': lines[i]} for i in range(len(lines))]
#keep the line segments within a threshold from slope of +/- 0.6
group_0 = [item for item in combined if item['slope'] > 0 and (item['slope'] - 0.6) * (item['slope'] - 0.6) < 0.03]
group_1 = [item for item in combined if item['slope'] < 0 and (item['slope'] + 0.6) * (item['slope'] + 0.6) < 0.03]
global previous_lines
if len(group_0) == 0 or len(group_1) == 0:
group_0_slope, group_0_intercept, group_1_slope, group_1_intercept = previous_lines
else:
def get_coordinates(group):
coordinates = []
for item in group:
for segment in item['line']:
x1, y1, x2, y2 = segment
coordinates.append([x1, y1])
coordinates.append([x2, y2])
return coordinates
group_0_coordinates = get_coordinates(group_0)
group_1_coordinates = get_coordinates(group_1)
group_0_slope, group_0_intercept, _, _, _ = stats.linregress(group_0_coordinates)
group_1_slope, group_1_intercept, _, _, _ = stats.linregress(group_1_coordinates)
def weighted_average_with_previous(value, previous_value):
weight = 0.01
return (value * weight) + (previous_value * (1 - weight))
if len(previous_lines) > 0:
previous_group_0_slope, previous_group_0_intercept, previous_group_1_slope, previous_group_1_intercept = previous_lines
group_0_slope = weighted_average_with_previous(group_0_slope, previous_group_0_slope)
group_0_intercept = weighted_average_with_previous(group_0_intercept, previous_group_0_intercept)
group_1_slope = weighted_average_with_previous(group_1_slope, previous_group_1_slope)
group_1_intercept = weighted_average_with_previous(group_1_intercept, previous_group_1_intercept)
previous_lines = (group_0_slope, group_0_intercept, group_1_slope, group_1_intercept)
lane_lines_intersection_x = (group_1_intercept - group_0_intercept) / (group_0_slope - group_1_slope)
lane_lines_intersection_y = group_0_slope * lane_lines_intersection_x + group_0_intercept
lane_lines_intersection = (int(round(lane_lines_intersection_x)), int(round(lane_lines_intersection_y)))
max_y = img.shape[0]
group_0_bottom_intersection_x = (max_y - group_0_intercept) / group_0_slope
group_1_bottom_intersection_x = (max_y - group_1_intercept) / group_1_slope
group_0_bottom_vertex = (int(round(group_0_bottom_intersection_x)), max_y)
group_1_bottom_vertex = (int(round(group_1_bottom_intersection_x)), max_y)
cv2.line(img, group_0_bottom_vertex, lane_lines_intersection, color, thickness)
cv2.line(img, group_1_bottom_vertex, lane_lines_intersection, color, thickness)
polygon_vertices = [group_0_bottom_vertex, lane_lines_intersection, group_1_bottom_vertex]
cv2.fillPoly(img, np.array([polygon_vertices]), (0,0,255))
# naive implementation
#for line in lines:
# for x1, y1, x2, y2 in line:
# cv2.line(img, (x1, y1), (x2, y2), color, thickness)
def hough_lines(img, rho, theta, threshold, min_line_len, max_line_gap):
"""
`img` should be the output of a Canny transform.
Returns an image with hough lines drawn.
"""
lines = cv2.HoughLinesP(img, rho, theta, threshold, np.array([]), minLineLength=min_line_len, maxLineGap=max_line_gap)
line_img = np.zeros((img.shape[0], img.shape[1], 3), dtype=np.uint8)
draw_lines(line_img, lines)
return line_img
# Python 3 has support for cool math symbols.
def weighted_img(img, initial_img, α=0.8, β=1., λ=0.):
"""
`img` is the output of the hough_lines(), An image with lines drawn on it.
Should be a blank image (all black) with lines drawn on it.
`initial_img` should be the image before any processing.
The result image is computed as follows:
initial_img * α + img * β + λ
NOTE: initial_img and img must be the same shape!
"""
return cv2.addWeighted(initial_img, α, img, β, λ)
Build your pipeline to work on the images in the directory "test_images"
You should make sure your pipeline works well on these images before you try the videos.
import os
os.listdir("test_images/")
Build the pipeline and run your solution on all test_images. Make copies into the test_images_output
directory, and you can use the images in your writeup report.
Try tuning the various parameters, especially the low and high Canny thresholds as well as the Hough lines parameters.
# TODO: Build your pipeline that will draw lane lines on the test_images
# then save them to the test_images directory.
def image_vertices(image):
imshape = image.shape
width = imshape[1]
height = imshape[0]
vertices = np.array([
[
(0.05 * width, height),
(0.35 * width, 0.6 * height),
(0.65 * width, 0.6 * height),
(0.95 * width, height) #,
#(0.55 * width, height),
#(0.5 * width, 0.65 * height),
#(0.45 * width, height)
]
], dtype=np.int32)
return vertices
def extract_lines(image,
polygon_vertices,
kernel_size = 5,
canny_low = 50,
canny_high = 150,
rho = 1,
theta = np.pi / 180,
hough_threshold= 30,
min_line_length = 10,
max_line_gap = 100
):
# grayscale the image
gray = grayscale(image)
# smooth it out a bit
smoothed = gaussian_blur(image, kernel_size)
# apply a canny filter for edge detection
edges = canny(smoothed, canny_low, canny_high)
# extract the interesting polygon
masked = region_of_interest(edges, polygon_vertices)
lines = hough_lines(masked, rho, theta, hough_threshold, min_line_length, max_line_gap)
return lines
for index, filename in enumerate(os.listdir("test_images/")):
image = mpimg.imread('test_images/' + filename)
previous_lines = []
line_image = extract_lines(image, image_vertices(image))
lines_added = weighted_img(line_image, image, α=0.95, β=1., λ=0.)
plt.figure(index + 1)
plt.imshow(lines_added)
You know what's cooler than drawing lanes over images? Drawing lanes over video!
We can test our solution on two provided videos:
solidWhiteRight.mp4
solidYellowLeft.mp4
Note: if you get an import error
when you run the next cell, try changing your kernel (select the Kernel menu above --> Change Kernel). Still have problems? Try relaunching Jupyter Notebook from the terminal prompt. Also, check out this forum post for more troubleshooting tips.
If you get an error that looks like this:
NeedDownloadError: Need ffmpeg exe.
You can download it by calling:
imageio.plugins.ffmpeg.download()
Follow the instructions in the error message and check out this forum post for more troubleshooting tips across operating systems.
# Import everything needed to edit/save/watch video clips
from moviepy.editor import VideoFileClip
from IPython.display import HTML
def process_image(image):
# NOTE: The output you return should be a color image (3 channel) for processing video below
# TODO: put your pipeline here,
# you should return the final output (image where lines are drawn on lanes)
line_image = extract_lines(image, image_vertices(image))
lines_added = weighted_img(line_image, image, α=0.95, β=1., λ=0.)
return lines_added
Let's try the one with the solid white lane on the right first ...
previous_lines = []
white_output = 'test_videos_output/solidWhiteRight.mp4'
## To speed up the testing process you may want to try your pipeline on a shorter subclip of the video
## To do so add .subclip(start_second,end_second) to the end of the line below
## Where start_second and end_second are integer values representing the start and end of the subclip
## You may also uncomment the following line for a subclip of the first 5 seconds
##clip1 = VideoFileClip("test_videos/solidWhiteRight.mp4").subclip(0,5)
clip1 = VideoFileClip("test_videos/solidWhiteRight.mp4")
white_clip = clip1.fl_image(process_image) #NOTE: this function expects color images!!
%time white_clip.write_videofile(white_output, audio=False)
Play the video inline, or if you prefer find the video in your filesystem (should be in the same directory) and play it in your video player of choice.
HTML("""
<video width="960" height="540" controls>
<source src="{0}">
</video>
""".format(white_output))
At this point, if you were successful with making the pipeline and tuning parameters, you probably have the Hough line segments drawn onto the road, but what about identifying the full extent of the lane and marking it clearly as in the example video (P1_example.mp4)? Think about defining a line to run the full length of the visible lane based on the line segments you identified with the Hough Transform. As mentioned previously, try to average and/or extrapolate the line segments you've detected to map out the full extent of the lane lines. You can see an example of the result you're going for in the video "P1_example.mp4".
 The new output should draw a single, solid line over the left lane line and a single, solid line over the right lane line. The lines should start from the bottom of the image and extend out to the top of the region of interest.
Now for the one with the solid yellow lane on the left. This one's more tricky!
yellow_output = 'test_videos_output/solidYellowLeft.mp4'
## To speed up the testing process you may want to try your pipeline on a shorter subclip of the video
## To do so add .subclip(start_second,end_second) to the end of the line below
## Where start_second and end_second are integer values representing the start and end of the subclip
## You may also uncomment the following line for a subclip of the first 5 seconds
##clip2 = VideoFileClip('test_videos/solidYellowLeft.mp4').subclip(0,5)
clip2 = VideoFileClip('test_videos/solidYellowLeft.mp4')
yellow_clip = clip2.fl_image(process_image)
%time yellow_clip.write_videofile(yellow_output, audio=False)
HTML("""
<video width="960" height="540" controls>
<source src="{0}">
</video>
""".format(yellow_output))
Try your lane finding pipeline on the video below. Does it still work? Can you figure out a way to make it more robust? If you're up for the challenge, modify your pipeline so it works with this video and submit it along with the rest of your project!
challenge_output = 'test_videos_output/challenge.mp4'
## To speed up the testing process you may want to try your pipeline on a shorter subclip of the video
## To do so add .subclip(start_second,end_second) to the end of the line below
## Where start_second and end_second are integer values representing the start and end of the subclip
## You may also uncomment the following line for a subclip of the first 5 seconds
##clip3 = VideoFileClip('test_videos/challenge.mp4').subclip(0,5)
clip3 = VideoFileClip('test_videos/challenge.mp4')
challenge_clip = clip3.fl_image(process_image)
%time challenge_clip.write_videofile(challenge_output, audio=False)
HTML("""
<video width="960" height="540" controls>
<source src="{0}">
</video>
""".format(challenge_output))


Afterwood
Every morning I struggle to get ready on time. No matter how hard I try I always seem to be leaving the house at 07:22 (+/- 30 seconds) and cycling like mad to the train station. As a consequence I then have about a minute and a half to lock my bike up and run around to the front of the station, pass through the ticket barrier, and then skip to the last carriage where I will find a seat waiting for me.
Possibly the least predictable part of this entire journey is passing through the ticket barrier inside the station. What makes this all the more tense is that I can see my train on the platform just the other side and the clock ticking overhead on the departure board, in my head I hear the clock tick hugely amplified as if I’m Jack Bauer in an episode of 24. I’ve put my ticket in, it’s been scanned and I know the back-end must have authorised me all in the blink of an eye but the barrier is mechanical and therefore subject to the laws of physics. I lift my arms to make myself as small as possible and eventually it opens wide enough for me to squeeze through and I’m out onto the platform before another barrier, this time the train doors, shuts me out.
Let’s wind the clock back a few years to when I was fortunate enough to be able to travel to Japan to spend the week with a couple of friends at the Tokyo Game Show. Pretty much all my holidays up to that point had been within the European continent and so I was expecting to feel like the proverbial “duck out of water” as I struggled in a country that used a completely different language for communicating, let alone the difference in culture and customs. Of course they drive on the same side of the road so that was one less thing to worry about, not that we would be driving.
Naturally to get around Tokyo we relied heavily on walking and public transport, most notably the rail system. There were many notable differences here too, such as the different little tune they play at each station at which point a whole bunch of seemingly fast-asleep passengers lurch for the door before the train departs. The other interesting difference I noticed was the barriers they used at the entrance to the platforms – they were open by default. Of course initially we applied our usual British Rail mentality and just tried walking straight through on the assumption that they clearly must be broken or the ticket inspector is outside having a smoke or gone for an extended toilet break. As I entered the barrier a small pair of doors closed swiftly in front of us! At first I was confused, when I stepped back the doors opened, but as I stepped forward they closed again. How strange… Taking a moment to watch the natives it soon became apparent where we needed to touch the machine with our smart card so that the doors would remain open and we could pass through without any further disruption.
Aside from the psychological differences, which I’ll come to in a moment, these two approaches have a very clear operational difference too. In the British case the barrier has to open and close for every single passenger, whereas the Japanese approach only requires the barrier to close when the passenger has forgotten to validate their ticket. This former’s need to continuously operate the barrier means that it likely requires more energy to run, has a far shorter maintenance cycle and potentially a higher mean time-to-fail. The Japanese approach is more optimal simply by doing less work.
But what raises my ire the most about the British barrier is the implicit assumption that I am a fare dodger until I have proven myself innocent by validating my ticket. Far from welcoming me to their facilities my initial experience is one of confrontation as I am challenged to make myself worthy. In stark contrast the Japanese barrier welcomes me (literally) with open arms and invites me to proceed, only barring my entry if I should accidentally make a mistake. You can almost hear the apology from the gates as they shut, sorry that they’ve had to temporarily disrupt your journey. The fact that they’re only knee high and therefore present no real obstacle means they’re really just a speed-bump rather than a barrier.
If only these kinds of barriers were limited to train stations.
Sadly we bump into the more metaphorical kind every day in the office. Instead of the culture making it easy to fall into the pit of success we find ourselves stumbling at every hurdle laid out in our path. The British-style barrier is the norm in most established organisations – you start from a position of being disallowed whatever it is you are after until you have collated enough “evidence” to justify your right to continue with your intended course of action. In essence the tactic is one of pessimism – make it hard to do anything and the chance of mistakes happening will be reduced.
So what’s the alternative? The Japanese-style barrier starts from a position of trust – it assumes that you are probably trying to do the right thing. This is one of optimism. But, crucially, it is not a naïve stance; an act of verification still has to occur. For the purposes of this analogy it would have been better if the Tokyo barriers had actually scanned my card after passing through the barrier, but I’ll have to settle for a leakier metaphor.
The saying “trust, but verify” has its roots in the Cold War where two vast nations were trying to avoid all-out nuclear war. Surely an organisation can start from a position of trusting its employees given that their mistakes will be far less costly?
Chris Oldwood
08 July 2016
Chris is a freelance programmer who started out as a bedroom coder in the 80’s writing assembler on 8-bit micros. These days it's enterprise grade technology in plush corporate offices. He also commentates on the Godmanchester duck race and can be easily distracted via<EMAIL_ADDRESS>or @chrisoldwood.


Keyboard Shortcuts
- Lists
- 1 Unread entries
- 2 Saved entries
- 3 All entries
- 4 All groups
- 5 Feeds
- Entry page
- k Next
- m Mark/unmark as read
- s Save/unsave
- v View entry on original website
Sync with Your Reader
Configure your favorite feed reader using your Coldsweat credentials and this web address:
{{request.application_url}}/fever
Command-line Utilities
Import and Export Subscriptions
Use the sweat
command-line script to import your subscription in OPML/XML format:
$ python sweat.py import /path/to/subscriptions.xml
Also, there is a export
command to save your subscriptions in OPML/XML format:
$ python sweat.py export /path/to/subscriptions.xml
Fetch Feeds
$ python sweat.py fetch
You should use Cron or similar utilities to schedule feeds fetch on a regular basis.
Get Support
- Check Coldsweat wiki for setup, deploy and developer information.
- Open an issue on GitHub


Properties
cmpVersion
cmpVersion: any
consentLanguage
consentLanguage: any
consentScreen
consentScreen: any
isServiceSpecific
isServiceSpecific: any
lastUpdated
lastUpdated: any
numCustomPurposes
numCustomPurposes: any
policyVersion
policyVersion: any
publisherConsents
publisherConsents: any
publisherCountryCode
publisherCountryCode: any
publisherCustomConsents
publisherCustomConsents: any
publisherCustomLegitimateInterest
publisherCustomLegitimateInterest: any
publisherLegitimateInterest
publisherLegitimateInterest: any
publisherRestrictions
publisherRestrictions: any
purposeConsents
purposeConsents: any
purposeLegitimateInterest
purposeLegitimateInterest: any
purposeOneTreatment
purposeOneTreatment: any
specialFeatureOptIns
specialFeatureOptIns: any
useNonStandardStacks
useNonStandardStacks: any
vendorConsents
vendorConsents: any
vendorLegitimateInterest
vendorLegitimateInterest: any
vendorListVersion
vendorListVersion: any
vendorsAllowed
vendorsAllowed: any
vendorsDisclosed
vendorsDisclosed: any
I need this interface to have type flexibility so I'm disabling eslint... Don't know if there is a better way to achieve this...


code
Enter SNOBOL4 statements for immediate execution. Also supports a primitive programming environment with line numbered statements.
Uses
BQ
CHARS
DDT
EDITLINE
HOST
READLINE
SEQ
SLOAD
VDIFFER
«INCLUDES»≡ -INCLUDE 'BQ.INC' -INCLUDE 'CHARS.INC' -INCLUDE 'DDT.INC' -INCLUDE 'EDITLINE.INC' -INCLUDE 'HOST.INC' -INCLUDE 'READLINE.INC' -INCLUDE 'SEQ.INC' -INCLUDE 'SLOAD.INC' -INCLUDE 'VDIFFER.INC' @
«code»≡ «signon» «manifest» «readline» «patterns» «functions» «main» «parse» «commands» «error function» «exit trap» «exit» @
Patterns used to parse commands.
«patterns»≡ QQ_ = '"' Q_ = "'" WHITE_SPACE_ = CHARS_HT ' ' OWS_ = SPAN(WHITE_SPACE_) | '' SF_PAT_ = FENCE ANY('SsFfEe') + (ANY(WHITE_SPACE_) | RPOS(0)) CMNT_PAT_ = FENCE ANY('*;|#!-') INPAT_ = FENCE '-' ((ANY('Ii') ('NCLUDE' | 'nclude')) | + (ANY('Cc') ('OPY' | 'opy'))) + BREAK(QQ_ Q_) LEN(1) BREAK(QQ_ Q_) . X * RETNPAT_ = FENCE (SPAN(&DIGITS) . LN_) + ((ANY(WHITE_SPACE_) REM . CODE) | '') RPOS(0) SAVEPAT_ = FENCE ANY('Ss') ('AVE' | 'ave') + ((BREAK(QQ_ Q_) LEN(1) BREAK(QQ_ Q_) . FN_ LEN(1)) + | '') + RPOS(0) LOADPAT_ = FENCE ANY('Ll') ('OAD' | 'oad') + ((BREAK(QQ_ Q_) LEN(1) BREAK(QQ_ Q_) . FN_ LEN(1)) + | '') + RPOS(0) NAMEPAT_ = FENCE ANY('Nn') ('AME' | 'ame') + ((BREAK(QQ_ Q_) LEN(1) BREAK(QQ_ Q_) . FN2_ LEN(1)) + | '') + RPOS(0) LISTPAT_ = FENCE ANY('Ll') ('IST' | 'ist') + ((ANY(WHITE_SPACE_) + ((OWS_ SPAN(&DIGITS) . N1_) | '') + ((OWS_ ',' OWS_ SPAN(&DIGITS) . N2_) | '') + ) | '') RPOS(0) RUNPAT_ = FENCE ANY('Rr') ('UN' | 'un') + (ANY(WHITE_SPACE_) SPAN(&DIGITS) . LN_ | '') + RPOS(0) EDITPAT_ = FENCE ANY('Ee') ('DIT' | 'dit') + (ANY(WHITE_SPACE_) SPAN(&DIGITS) . LN_ | '') + RPOS(0) RENUMPAT_ = FENCE ANY('Rr') ('ENUM' | 'enum') + (ANY(WHITE_SPACE_) SPAN(&DIGITS) . LN_ | '') + RPOS(0) QUITPAT_ = FENCE ANY('Qq') ('UIT' | 'uit') RPOS(0) NEWPAT_ = FENCE ANY('Ss') ('CRATCH' | 'cratch') RPOS(0) DDTPAT_ = FENCE ANY('Dd') ('DT' | 'dt') RPOS(0) EVALPAT_ = FENCE '=' REM . CODE EXECPAT_ = FENCE '!' REM . CODE HELPPAT_ = FENCE '?' @
Clear the retained program. Create the last label NMAX_ + 1 and have that branch to label E. Then, fill in the rest of the statements L__1 to L__<NMAX_>.
This is an expensive operation. With NMAX_ at its default (9999), 10,000 statements are compiled here.
On a scratch, the default filename is set back to SCRATCH.
| CODE: SCRATCH
«clear»≡ CLEAR_ FN_ = 'SCRATCH' CODE('L__' NMAX_ + 1 ' :(E)') SRC_ = ARRAY(NMAX_) SEQ(" CODE(SRC_<N> 'L__' N ' :(L__' N + 1 ')')", .N) :(RETURN) @
Command processors for code. The first handler must be immediate because the parser will fall through on any command not otherwise parseable.
«commands»≡ «immediate» «retained» «edit» «ddt» «run» «list» «save» «load» «name» «renum» «complete» «eval» «shell» «help» @
Default is immediate execution. Compile and execute the line entered.
| CODE: X = 12
«immediate»≡ INPT_ SF_PAT_ :S(SF_ERR_) CODE = CODE(INPT_ ' :S(S) F(F)') :S<CODE> CPLERR_ TERMINAL = 'COMPILATION ERROR: ' &ERRTEXT TERMINAL = 'REENTER STATEMENT OR EDIT ' LN_ :(RETURN) S TERMINAL = 'SUCCESS' :(RETURN) F TERMINAL = 'FAILURE' :(RETURN) SF_ERR_ TERMINAL = "CANNOT USE 'S', 'F', OR 'E' AS A LABEL WITH CODE" + :(RETURN) @
Compile in retained statement (1..NMAX_). The statement can be empty to delete the statement previously entered. Compiled statements are surroundeD by L__10; STATEMENT; :(L__11) to allow control to proceed from one statement to the next. The final label is L__<MAX> which is defined as the program exit. Each statement is preceeded by a statement setting LN_ to the current statement number - this is used to display the retained program line if break or an error occurs.
Source text is retained in array SRC_.
| CODE: 1 X = 12 ADD OR REPLACE LINE 1 | CODE: 1 REMOVE LINE 1 | CODE: 2 -INCLUDE 'SEQ' INCLUDE SEQ. NOTE THAT INCLUDE IS | DONE ON ENTRY (WHICH IS WHEN THE COMPILE | IS DONE). | CODE: 3 * COMMENT COMMENTS ARE COMPILED TO EMPTY, BUT ARE | RETAINED. (IN SRC_<>)
Continuation lines are not supported. The way a continuation is expressed means that we can't compile until we know that no further continuation lines will be given. But our basic flow is to compile the new source immediately, and retain the source line. For this reason, the SAVE format is not directly compatible with the compiler. We add the line number and a space (5 characters) to the front. The deretn (de-retain) utility strips this. code is not meant to be used to edit or test existing programs - simply to try ideas and perhaps produce the basics of new programs.
Statement numbers (&STNO) are assigned as increasing integers. This could also be recorded (may be useful for STCOUNT traps and profiling). We don't yet record statement numbers. Simple line number breakpoints can be implemented by trapping on variable LN_. If it matched the desired line number, we could break.
Before the actual code, a statement is compiled which tracks the line number, assigning it to LN_. This is reported on errors, in order to track the error to the offending statement.
«retained»≡ RETN_ CHECKLN_(LN_) :F(RETURN) SRC_<LN_> = CODE CODE CMNT_PAT_ :S(CMNT_) CODE('L__' +LN_ ' LN_ = ' +LN_ ';' CODE '; :(L__' LN_ + 1 ')') + :S(RETURN)F(CPLERR_) CMNT_ CODE INPAT_ :F(CMNT2_) SLOAD(X) CMNT2_ CODE('L__' LN_ ' :(L__' LN_ + 1 ')') :(RETURN) @
Edit a line in the retained program, or the entire retained program.
When the entire retained program is edited, the editor is presented with a source with no line numbers. When editing is complete, this is read in, and line numbers assigned beginning with 1 and stepping by 1. RENUM may then be used. This loses the line number information originally in the retained program, but allows syntax highlighting and other features of the external editor to be exploited.
The external editor could be (horribly) misused to import source into code (edit, and then read the source in, and save/exit back to code). This also provides export (but see deretn).
| CODE: EDIT 1 EDIT LINE 30 (USING READLINE) | CODE: EDIT EDIT USING EXTERNAL EDITOR
«edit»≡ EDIT_ DIFFER(LN_) :S(EDIT2_) TEMP_ = BQ('mktemp') UNIT = IO_FINDUNIT() OUTPUT(.F, UNIT,, TEMP_) :F(FILERR_) SEQ(' F = VDIFFER(SRC_<N>); SRC_<N> ', .N) ENDFILE(UNIT) DETACH(.F) UNIT = IO_FINDUNIT() INPUT(.F, UNIT,, TEMP_) :F(FILERR_) HOST(HOST_SYSCMD, EDITOR ' ' TEMP_) FN2_ = FN_ CLEAR_() FN_ = FN2_ LN_ = 1 EDIT3_ INPT_ = LN_ ' ' F :F(EDIT4_) PRSLIN_() LN_ = LN_ + 1 :(EDIT3_) EDIT4_ ENDFILE(UNIT) DETACH(.F) DELETE(TEMP_) :(RETURN) EDIT2_ CHECKLN_(LN_) :F(RETURN) INPT_ = EDITLINE('EDIT: ', LPAD(LN_, 4, '0') ' ' SRC_<LN_>) + :(PRSLIN_) @
Use DDT to debug the retained program.
Saves file with an entry to DDT() jammed in as the first lines. An END label is added at the end. The file is compiled with a listing, and then spawned as a separate process. We assume that the subprocess wilL be ok with the standard options - but we do add -b to suppress the normal banner. Label CODE_RETAINED_PROGRAM is inserted to allow DDT's LABEL+OFFSET to make sense on initial entry. Label E is added to the end, because it is possible that :(E) is used in the retained program (instead of :(END)). END is typically not used in the retained program because it is being prepared interactively.
| CODE: DDT
We copy all lines beginning with -INCLUDE before inserting the DDT codes. This allows debugging retained programs with -INCLUDE directives. Because of single inclusion, we don't bother removing the lines from the rest of the source. They won't do anything.
«ddt»≡ DDT__ TERMINAL = 'STARTING DDT' TEMPSRC_ = BQ('mktemp') TEMPLST_ = BQ('mktemp') UNIT = IO_FINDUNIT() OUTPUT(.F, UNIT,, TEMPSRC_) :F(FILERR_) F = "-INCLUDE 'DDT.INC'" SEQ(' F = ?(SRC_<N> ? INPAT_) SRC_<N>; SRC_<N> ', .N) F = ' DDT()' F = 'CODE_RETAINED_PROGRAM' SEQ(' F = VDIFFER(SRC_<N>); SRC_<N> ', .N) F = 'E' F = 'END' ENDFILE(UNIT) DETACH(.F) HOST(HOST_SYSCMD, 'snobol4 -n -b -l ' TEMPLST_ ' ' TEMPSRC_) HOST(HOST_SYSCMD, 'LIST=' TEMPLST_ ' snobol4 -B -b ' TEMPSRC_) TERMINAL = 'DDT COMPLETED' DELETE(TEMPSRC_) DELETE(TEMPLST_) :(RETURN) @
Run retained program. Transfer control to first line L__1, or specified line.
| CODE: RUN RUN FROM LINE 1 | CODE: RUN 50 RUN FROM LINE 50
«run»≡ RUN_ LN_ = IDENT(LN_) 1 CHECKLN_(LN_) :F(RETURN) &TRACE = 0 :($('L__' LN_)) @
List retained program.
| CODE: LIST LIST ALL LINES | CODE: LIST 10 LIST LINE 10 | CODE: LIST 10,50 LIST LINES BETWEEN 10 AND 50 | CODE: LIST ,50 LIST ALL LINES UP TO 50
«list»≡ LIST_ N2_ = IDENT(N2_) VDIFFER(N1_) SEQ(' TERMINAL = LPAD(N, 4, "0") " " VDIFFER(SRC_<N>); ' + ' SRC_<N> ', .N, N1_, N2_) :(RETURN) @
Save retained program. Default file is SCRATCH.
| CODE: SAVE SAVE TO LAST FILENAME | CODE: SAVE 'MYFILE' SAVE TO MYFILE
«save»≡ SAVE_ TERMINAL = 'SAVING TO ' FN_ UNIT = IO_FINDUNIT() OUTPUT(.F, UNIT,, FN_) :F(FILERR_) SEQ(' F = LPAD(N, 4, "0") " " VDIFFER(SRC_<N>); ' + ' SRC_<N> ', .N) ENDFILE(UNIT) DETACH(.F) :(RETURN) @
Load retained program. Default file is SCRATCH. If another name is given, remember for future SAVE (or LOAD). Doesn't clear the retained program, allowing programs to be merged. Use SCRATCH before LOAD if required.
| CODE: LOAD LOAD FROM LAST FILENAME | CODE: LOAD 'MYFILE' LOAD FROM MYFILE
«load»≡ LOAD_ TERMINAL = 'LOADING FROM ' FN_ UNIT = IO_FINDUNIT() INPUT(.F, UNIT,, FN_) :F(FILERR_) LOAD2_ INPT_ = F :F(LOAD3_) PRSLIN_() :(LOAD2_) LOAD3_ ENDFILE(UNIT) DETACH(.F) :(RETURN) FILERR_ TERMINAL = 'CANNOT OPEN FILE' :(RETURN) @
NAME displays current name, or sets new name
| CODE: NAME DISPLAY FILENAME | CODE: NAME 'MYFILE' SET FILENAME
«name»≡ NAME_ TERMINAL = IDENT(FN2_) 'FILE: ' FN_ :S(RETURN) FN_ = FN2_ :(RETURN) @
RENUM (assign new line numbers) to retained program. Uses 10 as the increment, unless there are too many lines, in which case 5 (4, 3, or even 2) may be used as increments (5 is preferred).
| CODE: RENUM RENUMBER FROM 10 BY 10 | CODE: RENUM 1000 RENUMBER FROM 1000 BY 10
«renum»≡ RENUM_ LN_ = IDENT(LN_) 10 CHECKLN_(LN_) :F(RETURN) SC = 0 SEQ(' SC = DIFFER(SRC_<N>) SC + 1; SRC_<N> ', .N) EQ(SC) :S(RETURN) Q = (NMAX_ - LN_) / SC TERMINAL = LE(Q, 1) 'TOO MANY LINES TO RENUMBER' :S(RETURN) INCR = 10 INCR = GE(Q, 5) LT(Q, 10) 5 INCR = GT(Q, 1) LT(Q, 5) Q TERMINAL = 'RENUMBERING BY ' INCR ' FROM ' LN_ UNIT = IO_FINDUNIT() INPUT(.IN, UNIT, 'U', '/dev/tmpfile') OUTPUT(.OUT, UNIT, 'W') SEQ(' OUT = LN_ " " VDIFFER(SRC_<N>); ' + ' LN_ = DIFFER(SRC_<N>) LN_ + INCR; SRC_<N> ', .N) FN2_ = FN_ CLEAR_() FN_ = FN2_ FN_ = VDIFFER(FN2_) RENUM2_ INPT_ = IN :F(RENUM3_) PRSLIN_() :(RENUM2_) RENUM3_ ENDFILE(UNIT) DETACH(.OUT) DETACH(.IN) :(RETURN) @
Label E for program completion.
«complete»≡ E TERMINAL = 'PROGRAM COMPLETE' :(RETURN) @
Evaluate and print expression
| CODE: =1 + 3
«eval»≡ EVAL_ TERMINAL = EVAL(CODE) :S(S)F(F) @
Shell to external program
| CODE: !ls
«shell»≡ EXEC_ HOST(HOST_SYSCMD, CODE) :(RETURN) @
Give help for the code program.
| CODE: ?
«help»≡ HELP_ TERMINAL = '=EXPRESSION DISPLAY VALUE OF EXPRESSION' TERMINAL = '!COMMAND SHELL OUT TO COMMAND' TERMINAL = '? THIS HELP' TERMINAL = 'STATEMENT EXECUTE STATEMENT' TERMINAL = TERMINAL = 'N STATEMENT ENTER/REPLACE/DELETE PROGRAM LINE' TERMINAL = 'RUN [N] RUN RETAINED PROGRAM' TERMINAL = 'DDT DDT ON RETAINED PROGRAM' TERMINAL = 'LIST [[N][,M]] LIST RETAINED PROGRAM' TERMINAL = 'EDIT [N] EDIT RETAINED PROGRAM' TERMINAL = "SAVE ['FILE'] SAVE RETAINED PROGRAM" TERMINAL = "LOAD ['FILE'] LOAD RETAINED PROGRAM" TERMINAL = "NAME ['FILE'] CHANGE OR DISPLAY NAME" TERMINAL = 'SCRATCH CLEAR RETAINED PROGRAM' TERMINAL = 'RENUM [N] RENUMBER RETAINED PROGRAM' TERMINAL = 'QUIT EXIT CODE' TERMINAL = TERMINAL = + '-INCLUDE IS PROCESSED IMMEDIATELY ON ENTRY. CONTINUATION LINES ARE' TERMINAL = + 'NOT AVAILABLE. LINES ARE IN THE RANGE 1..' NMAX_ TERMINAL = TERMINAL = 'S, F, AND E LABELS AVAILABLE' TERMINAL = 'SLOAD(' Q_ 'FILE' Q_ ') AVAILABLE' :(RETURN) @
Hoary interactions between ERRFUN_ and BRKFUN_. We need ERRFUN_ in some conditions, but the EXIT trap may be triggered anyway on return from ERRFUN_.
«error function»≡ ERRFUN_ (NE(&ERRTYPE, 34) SETEXIT()) EQ(&ERRTYPE, 34) :S(RETURN) TERMINAL = 'EXECUTION ERROR #' &ERRTYPE ', ' &ERRTEXT TERMINAL = 'RETAINED PROGRAM LINE:' DIFFER(LN_) TERMINAL = LPAD(VDIFFER(LN_), 4, 0) ' ' SRC_<LN_> :(RETURN) @
If BRKFUN_ (exit trap) is entered, we need to know if we should simply resume from the command prompt, or return (again, probably to the prompt). Our heuristic is to test &FNCLEVEL, and return if it is 1. If it is 0, a simple branch suffices. If > 0, we also branch, and (lose) the stack. DDT has a similar problem. Here, we keep track of &FNCLEVEL in FL_, for reporting and making return/branch decision.
The issue is that we cannot simply pop the function stack and bindings. After getting input, and executing RUN, we are one function deep (NEWLIN_ -> PRSLIN_()). If we see one level here, we know that we can simply return and this brings us back to NEWLIN_. But, since the only thing we *can* do is return, if the level is 2 or greater, we cannot return (we would wind up back in the faulty code).
I would like to be able to pop levels off, until only one remains, (or zero) and then return, or branch. But I can't! Each function level will also lock parameters and locals. To get around that memory leakage, PRSLIN_() has no parameters, and no locals.
«exit trap»≡ BRKFUN_ ERRTYPE_ = &ERRTYPE ERRTEXT_ = &ERRTEXT @
Getting to END triggers &ERRTYPE 0. We don't display anything, but want to get back to the prompt. An expected END will have removed the SETEXIT() trap, and we won't wind up here.
Unfortunately, FATAL errors are not trapped. For example
| CODE: :(NO_SUCH_LABEL) ;
will immediately bail code. So, SAVE before RUN. Just prudent. Note that labels are not checked until run-time and not compile-time.
«exit trap»≡ EQ(ERRTYPE_, 0) EQ(&FNCLEVEL, FL_ + 1) :S(RETURN) EQ(ERRTYPE_, 0) :S(NEWLIN_) SETEXIT('BRKFUN_') &ERRLIMIT = 999999999 TERMINAL = 'ERROR ' ERRTYPE_ ' (' ERRTEXT_ ')' + ' AT LEVEL ' &FNCLEVEL - FL_ - 1 TERMINAL = 'RETAINED PROGRAM LINE:' DIFFER(LN_) TERMINAL = LPAD(VDIFFER(LN_), 4, 0) ' ' SRC_<LN_> EQ(&FNCLEVEL, FL_ + 1) :S(RETURN)F(NEWLIN_) @
Main program. Re-establish EXIT handler, input a line, parse and execute it, and then get the next line. Note that history expansion is done, but lines that begin with ! are considered special. Those lines are assumed to be external shell execution. The leading ! is stripped, then history expansion is done, and the ! is added back.
Empty lines are not added to the history. The current FNCLEVEL is recorded for error handling.
«main»≡ «initialize» NEWLIN_ SETEXIT('BRKFUN_') &TRACE = 999999999 &ERRLIMIT = 999999999 INPT_ = READLINE('CODE:') :F(EXIT_) INPT_ FENCE '!' REM . CODE :F(NEWL2_) CODE = HISTORY_EXPAND(CODE) INPT_ = '!' CODE :(NEWL3_) NEWL2_ INPT_ = HISTORY_EXPAND(INPT_) NEWL3_ INPT_ = TRIM(INPT_) ADD_HISTORY(VDIFFER(INPT_)) FL_ = &FNCLEVEL PRSLIN_() :(NEWLIN_) @
Parse the input line, branching to the execution routine.
«parse»≡ PRSLIN_ N1_ = N2_ = CODE = LN_ = FN2_ = INPT_ EVALPAT_ :S(EVAL_) INPT_ EXECPAT_ :S(EXEC_) INPT_ HELPPAT_ :S(HELP_) INPT_ LISTPAT_ :S(LIST_) INPT_ RUNPAT_ :S(RUN_) INPT_ EDITPAT_ :S(EDIT_) INPT_ QUITPAT_ :S(EXIT_) INPT_ NEWPAT_ :S(CLEAR_) INPT_ RENUMPAT_ :S(RENUM_) INPT_ SAVEPAT_ :S(SAVE_) INPT_ LOADPAT_ :S(LOAD_) INPT_ NAMEPAT_ :S(NAME_) INPT_ DDTPAT_ :S(DDT__) INPT_ RETNPAT_ :S(RETN_) @
«functions»≡ * DEFINE('ERRFUN_()') DEFINE('PRSLIN_()') DEFINE('CHECKLN_(N)') DEFINE('CLEAR_()') :(FN_END_) * «checkln» «clear» * FN_END_ @
«checkln»≡ CHECKLN_ GT(N) LE(N, NMAX_) :S(RETURN) TERMINAL = 'LINE NUMBER MUST BE 1 TO ' NMAX_ :(FRETURN) @
Trap and report conditionally fatal execution errors in user's code.
«initialize»≡ &TRACE = 999999999 TRACE('ERRTYPE', 'KEYWORD',, 'ERRFUN_') CLEAR_() @
«signon»≡ TERMINAL = 'CODE (TUE NOV 26 12:25:23 EST 2013)' TERMINAL = 'ENTER SNOBOL4 STATEMENTS (TRY ? FOR HELP)' @
«manifest»≡ NMAX_ = 9999 EDITOR = 'ED' @
«readline»≡ RLAPPNAME('CODE') READ_HISTORY('.CODE') STIFLE_HISTORY(50) @
«exit»≡ EXIT_ WRITE_HISTORY('.CODE') SETEXIT() @
We have thousands of statements chained together with gotos. These are traced during COLLECT() and the stack must be large enough. 10,000 empty statements take around 2.5MB of memory, leaving over 5MB for user (with 8MB default).
A stack size -S of 40000 seems to be fine.
«»≡ #!/usr/bin/bash exec "snobol4" "-s" "-S 40000" "$0" "$@" * -PROGRAM CODE -TITLE CODE START_ «INCLUDES» -STITL -EJECT * ************************************************************************ * * * ##### ####### ###### ####### * * # # # # # # # * * # # # # # # * * # # # # # ##### * * # # # # # # * * # # # # # # # * * ##### ####### ###### ####### * * * * CODE ENTER TEST SNOBOL4 STATEMENTS * * * * (C) COPYRIGHT 1985, 1987 - CATSPAW, INCORPORATED * * * * "THIS IS MY GRANDFATHER'S AXE. MY FATHER REPLACED THE HAFT, AND I * * PUT A NEW HEAD ON IT. IT'S MY GRANDFATHER'S AXE." * * * * ALSO PROVIDES A SIMPLISTIC RETAINED PROGRAM ENVIRONMENT (SIMILAR TO * * BASIC -- INSPIRED BY MTS) * * * ************************************************************************ * * code.lss * «code» END START_ * * CE: .MSNOBOL4; @


Computer science is a bad term and doesn’t describe the deeper and hidden processes in the same way that Biology is not just about using microscopes and petri dishes. Computer science is more than just using a computer to solve problems.
Computer Science is beautiful in that the barrier between what you can imagine and what you can build is pretty thin. Unlike other disciplines, like engineering where making components has a physical limitation. You can’t stack a million amplifiers and expect zero noise propagation, whereas computer science has ideal components. Pure functions can be stacked fed into each other without error propagating.
The idea of black box abstraction allows us to encapsulate ideas and pass them around.
In Lisp, as for any language, there are three main things.
1. Primitive Elements
What are the elementary building blocks of the language?
Here are some:
(
)
+
5
and 2
2. Combinations
How do we combine elementary building blocks to form ideas?
(+ 5 2)
The +
is the operator and takes two operands 5
and 2
. Basic syntax for Lisp uses prefix notation. Parenthesis make combinations unambiguous and are necessary. A linear sequence of characters describes a tree of operations.
(+ 3 (+ 1 4) 7 8)
3. Abstractions
How do we abstract these combinations out?
(defn square [x] (* x x))
Clojure’s syntax
Here, we’re defining a process of taking some value x
and multiplying *
it by itself and naming it square
. In essence, the symbol square
is just a name for lambda(x)
, which is a signal that means make a procedure for x
.


| db-misc {dbplyr} | R Documentation |
db_connection_describe()
provides a short string describing the
database connection, helping users tell which database a table comes
from. It should be a single line, and ideally less than 60 characters wide.
db_connection_describe(con) sql_join_suffix(con, ...) db_sql_render(con, sql, ...) dbplyr_edition(con)
dbplyr_edition()
declares which version of the dbplyr API you want.
See below for more details.
dplyr 2.0.0 renamed a number of generics so that they could be cleanly moved from dplyr to dbplyr. If you have an existing backend, you'll need to rename the following methods.
dplyr::db_desc()
-> dbplyr::db_connection_describe()
(also note that
the argument named changed from x
to con
).
Other generic:
db-sql
,
db_copy_to()
,
sql_escape_logical()


Banka
Home
Admin
Admin
Create Account
Sign-Up
Sign-In
Contact Us
My Profile
Passport
Photograph
Name:
Phone Number:
Address:
BVN:
Account Number:
Account Type:
Account Status:
Akin Obinna Ahmed
0803-123-4567
Plot 165, Abidjan Wuse Zone 2, Abuja
0123456789
0094578987
Corporate Account
Active


These services are available:
Ontology Translation UI
Template Mapping UI
Property Mapping UI
Triples UI
Mappings UI


{% seo title=false %}
{% include header.html %}
A Simple Idea can
Change the World
We're all working together, that's the secret.
{% include about.html %} {% include members.html %} {% include project.html %} {% include contact.html %} {% include footer.html %}


Introduction
Two separate treebanks are currenlty available for Slovenian: the default Slovenian UD Treebank and the Spoken Slovenian UD Treebank (SST).
The Slovenian UD Treebank
The Slovenian UD Treebank is based on the ssj500k Dependency Treebank (Krek et al. 2013), a representative balanced collection of sampled texts from the reference FidaPLUS corpus of written Slovenian (Arhar and Gorjanc 2007) that have been manually segmented, tokenized, lemmatized and morphosyntactically tagged in accordance with the JOS annotation scheme (Erjavec et al. 2010). Additionnally, approximately one half of the ssj500k corpus (known as the ssj200k subcorpus) includes manually annotated dependency relations and this is what has been used as the basis of the Slovenian UD Treebank.
The conversion from the ssj200k treebank to the Slovenian UD Treebank was completely automatic, based on a large set of rules on both morphosyntactic and syntactic layer, which include different lexical, morphological and dependency features. Due to the specifics of the original JOS syntactic annotation scheme, not all dependency relations from the original ssj200k treebank could be converted automatically, resulting in a slightly smaller size of the Slovenian UD treebank.
The current verison of the Slovenian UD Treebank thus contains 7,996 sentences with 140,418 tokens taken from various text types, e.g. fiction, non-fiction and periodicals, dating from 1990-2000. The original JOS annotations are included as part of the POSTAG (JOS morphosyntactic tags) and MISC (JOS dependency heads and labels) columns of the CONLLU format. Further revisions of this work, addition of new conversion rules and syntactic annotation guidelines remain a work in progress.
The conversions and guidelines have been contributed by Kaja Dobrovoljc, Tomaž Erjavec and Simon Krek.
Acknowledgments
We wish to thank all of the contributors to the original ssj500k training corpus: Kristina Bizjak, Živa Blaževič, Klara Canzutti, Lea Cibrič, Kaja Dobrovoljc, Tadeja Dušej, Tomaž Erjavec, Ivana Fekeža, Nanika Holz, Urška Kamenšek, Simon Krek, Andreja Košir, Robert Kuret, Nina Ledinek, Andrej Lovšin, Boštjan Marhold, Nina Mikulin, Barbara Modrijan, Sara Može, Tanja Novak, Lea Peršič, Tanja Radovič, Simona Šinkovec, Urška Vranjek, Jerneja Umer, Petra Žalodec.
The Spoken Slovenian UD Treebank (SST)
The Spoken Slovenian UD Treebank (SST) is the first syntactically annotated corpus of spoken Slovenian. The manual annotations have been performed on a representative sample of the reference Gos corpus of spoken Slovenian (Zwitter Vitez et al. 2013), a collection of transcribed audio recordings of monologic, dialogic and multi-party spontaneous speech in different everyday situations. The treebank is representative of speakers (sex, age, region, education), communication channels (TV, radio, telephone, personal contact) and communication settings (TV and radio shows, lectures, meetings, services, conversations between friends etc.).
The spelling, tokenization and segmentation principles follow the transcription guidelines of the reference corpus (Verdonik et al. 2013) with the syntactic trees spanning over individual utterances (semantically, syntactically and acoustically delimited units, roughly corresponding to written sentences). The SST treebank includes manual annotations of lemmas, part-of-speech categories, morphological features and dependency relations in accordance with the Universal Dependencies annotation scheme. In addition to language-specific extensions, in line with the written Slovenian UD Treebank, the SST treebank also includes new speech-specific extensions to accommodate the structural and pragmatic particularities of spoken language syntax, such as disfluencies, fillers, parentheticals, general extenders etc. More information on the treebank construction and annotation is given in (Dobrovoljc and Nivre 2016).
The current version of the SST treebank includes 29,488 tokens or 3,188 utterances, produced by 606 speakers in 287 different speech events.
The treebank construction and annotation was carried out by Kaja Dobrovoljc under the supervision of Joakim Nivre.
References
- Špela Arhar and Vojko Gorjanc. 2007. Korpus FidaPLUS: nova generacija slovenskega referenčnega korpusa (The FidaPLUS corpus: a new generation of the Slovene reference corpus). Jezik in slovstvo, 52(2).
- Kaja Dobrovoljc and Joakim Nivre. 2016. The Universal Dependencies Treebank of Spoken Slovenian. In: Proceedings of the Tenth International Conference on Language Resources and Evaluation (LREC’16), Portorož, Slovenia.
- Tomaž Erjavec, Darja Fišer, Simon Krek and Nina Ledinek. 2010. The JOS Linguistically Tagged Corpus of Slovene. In: Proceedings of the Seventh International Conference on Language Resources and Evaluation (LREC’10), Malta.
- Simon Krek, Tomaž Erjavec, Kaja Dobrovoljc, Sara Može, Nina Ledinek and Nanika Holz. 2013. Training corpus ssj500k 1.3. http://hdl.handle.net/11356/1029.
- Darinka Verdonik, Iztok Kosem, Ana Zwitter Vitez, Simon Krek and Marko Stabej. 2013. Compilation, transcription and usage of a reference speech corpus: the case of the Slovene corpus GOS. Language Resources and Evaluation, 47(4):1031–1048.
- Ana Zwitter Vitez, Jana Zemljarič Miklavčič, Simon Krek, Marko Stabej and Tomaž Erjavec. 2013. Spoken corpus Gos 1.0. Slovenian language resource repository CLARIN.SI. http://hdl.handle.net/11356/1040.


Apple: new event on December 2 dedicated to applications and games
by AbdullahApple: new event on December 2 dedicated to applications and games
5 (100%) 1 vote
Apple is about to conclude 2019 with a further press event. But there will be no talk of new hardware devices but rather apps and games, the best ones published in the App Store during the year. The Cupertino company concluded the cycle of announcements of new products a few days ago with the introduction of the new MacBook Pro 16″, but there is still another appointment set for December 2 next in New York.
The company led by Tim Cook has begun to send out invitations to the media through which you can see clearly what the subject of the presentation: “Join us for an Apple special event honoring our favorite apps and games of 2019”. It’s worth mentioning that the company annually announces the best apps and games. For iPhone, iPad, Mac and Apple TV. But so far it has done so with a simple statement, without organizing a real press event.
Apple services
Over the last year the company has stepped up its investments in the services sector. Activating new ones – think of Apple News +, TV+ and Arcade. It, therefore, appears to be consistent with the desire to diversify the offer, not only focusing on the sale of devices, to give even greater emphasis to what has always been one of the pillars of the Apple ecosystem, namely the App Store.
This year the winner of the best games category could emerge from the selection of titles included in the Apple Arcade. It has recently cut the milestone of the 100 titles included in the service.


{{studentSelected.fname}} {{studentSelected.lname}}
{{studentSelected.standard}}
- ROLLNO:
- {{studentSelected.rollno}}
- Name:
- {{studentSelected.fname}} {{studentSelected.lname}}
- Standard:
- {{studentSelected.standard}}
- Update Date:
- {{studentSelected.updated_date | date}}
edit
delete


Intrinsicly foster alternative action items rather than standardized manufactured products. Efficiently build emerging models without coval.
Convergence vis anvis stand alone paradigms.
Intrinsicly foster alternative action items rather than standardized manufactured products. Efficiently build emerging models without coval.


Basic Operators
An operator is a special symbol or phrase that you use to check, change, or combine values. For example, the addition operator (+
) adds two numbers, as in let i = 1 + 2
, and the logical AND operator (&&
) combines two Boolean values, as in if enteredDoorCode && passedRetinaScan
.
Swift supports most standard C operators and improves several capabilities to eliminate common coding errors. The assignment operator (=
) doesn’t return a value, to prevent it from being mistakenly used when the equal to operator (==
) is intended. Arithmetic operators (+
, -
, *
, /
, %
and so forth) detect and disallow value overflow, to avoid unexpected results when working with numbers that become larger or smaller than the allowed value range of the type that stores them. You can opt in to value overflow behavior by using Swift’s overflow operators, as described in Overflow Operators.
Swift also provides range operators that aren’t found in C, such as a..<b
and a...b
, as a shortcut for expressing a range of values.
This chapter describes the common operators in Swift. Advanced Operators covers Swift’s advanced operators, and describes how to define your own custom operators and implement the standard operators for your own custom types.
Terminology
Operators are unary, binary, or ternary:
Unary operators operate on a single target (such as
-a
). Unary prefix operators appear immediately before their target (such as!b
), and unary postfix operators appear immediately after their target (such asc!
).Binary operators operate on two targets (such as
2 + 3
) and are infix because they appear in between their two targets.Ternary operators operate on three targets. Like C, Swift has only one ternary operator, the ternary conditional operator (
a ? b : c
).
The values that operators affect are operands. In the expression 1 + 2
, the +
symbol is a binary operator and its two operands are the values 1
and 2
.
Assignment Operator
The assignment operator (a = b
) initializes or updates the value of a
with the value of b
:
let b = 10
var a = 5
a = b
// a is now equal to 10
If the right side of the assignment is a tuple with multiple values, its elements can be decomposed into multiple constants or variables at once:
let (x, y) = (1, 2)
// x is equal to 1, and y is equal to 2
Unlike the assignment operator in C and Objective-C, the assignment operator in Swift does not itself return a value. The following statement is not valid:
if x = y {
// This is not valid, because x = y does not return a value.
}
This feature prevents the assignment operator (=
) from being used by accident when the equal to operator (==
) is actually intended. By making if x = y
invalid, Swift helps you to avoid these kinds of errors in your code.
Arithmetic Operators
Swift supports the four standard arithmetic operators for all number types:
Addition (
+
)Subtraction (
-
)Multiplication (
*
)Division (
/
)
1 + 2 // equals 3
5 - 3 // equals 2
2 * 3 // equals 6
10.0 / 2.5 // equals 4.0
Unlike the arithmetic operators in C and Objective-C, the Swift arithmetic operators don’t allow values to overflow by default. You can opt in to value overflow behavior by using Swift’s overflow operators (such as a &+ b
). See Overflow Operators.
The addition operator is also supported for String
concatenation:
"hello, " + "world" // equals "hello, world"
Remainder Operator
The remainder operator (a % b
) works out how many multiples of b
will fit inside a
and returns the value that is left over (known as the remainder).
Here’s how the remainder operator works.
In Swift, this would be written as:
9 % 4 // equals 1
To determine the answer for a % b
, the %
operator calculates the following equation and returns remainder
as its output:
a
= (b
x some multiplier
) + remainder
where some multiplier
is the largest number of multiples of b
that will fit inside a
.
Inserting 9
and 4
into this equation yields:
9
= (4
x 2
) + 1
The same method is applied when calculating the remainder for a negative value of a
:
-9 % 4 // equals -1
Inserting -9
and 4
into the equation yields:
-9
= (4
x -2
) + -1
giving a remainder value of -1
.
The sign of b
is ignored for negative values of b
. This means that a % b
and a % -b
always give the same answer.
Unary Minus Operator
The sign of a numeric value can be toggled using a prefixed -
, known as the unary minus operator:
let three = 3
let minusThree = -three // minusThree equals -3
let plusThree = -minusThree // plusThree equals 3, or "minus minus three"
The unary minus operator (-
) is prepended directly before the value it operates on, without any white space.
Unary Plus Operator
The unary plus operator (+
) simply returns the value it operates on, without any change:
let minusSix = -6
let alsoMinusSix = +minusSix // alsoMinusSix equals -6
Although the unary plus operator doesn’t actually do anything, you can use it to provide symmetry in your code for positive numbers when also using the unary minus operator for negative numbers.
Compound Assignment Operators
Like C, Swift provides compound assignment operators that combine assignment (=
) with another operation. One example is the addition assignment operator (+=
):
var a = 1
a += 2
// a is now equal to 3
The expression a += 2
is shorthand for a = a + 2
. Effectively, the addition and the assignment are combined into one operator that performs both tasks at the same time.
For information about the operators provided by the Swift standard library, see Operator Declarations.
Comparison Operators
Swift supports all standard C comparison operators:
Equal to (
a == b
)Not equal to (
a != b
)Greater than (
a > b
)Less than (
a < b
)Greater than or equal to (
a >= b
)Less than or equal to (
a <= b
)
Each of the comparison operators returns a Bool
value to indicate whether or not the statement is true:
1 == 1 // true because 1 is equal to 1
2 != 1 // true because 2 is not equal to 1
2 > 1 // true because 2 is greater than 1
1 < 2 // true because 1 is less than 2
1 >= 1 // true because 1 is greater than or equal to 1
2 <= 1 // false because 2 is not less than or equal to 1
Comparison operators are often used in conditional statements, such as the if
statement:
let name = "world"
if name == "world" {
print("hello, world")
} else {
print("I'm sorry \(name), but I don't recognize you")
}
// Prints "hello, world", because name is indeed equal to "world".
For more on the if
statement, see Control Flow.
You can compare two tuples if they have the same type and the same number of values. Tuples are compared from left to right, one value at a time, until the comparison finds two values that aren’t equal. Those two values are compared, and the result of that comparison determines the overall result of the tuple comparison. If all the elements are equal, then the tuples themselves are equal. For example:
(1, "zebra") < (2, "apple") // true because 1 is less than 2; "zebra" and "apple" are not compared
(3, "apple") < (3, "bird") // true because 3 is equal to 3, and "apple" is less than "bird"
(4, "dog") == (4, "dog") // true because 4 is equal to 4, and "dog" is equal to "dog"
In the example above, you can see the left-to-right comparison behavior on the first line. Because 1
is less than 2
, (1, "zebra")
is considered less than (2, "apple")
, regardless of any other values in the tuples. It doesn’t matter that "zebra"
isn’t less than "apple"
, because the comparison is already determined by the tuples’ first elements. However, when the tuples’ first elements are the same, their second elements are compared—this is what happens on the second and third line.
Tuples can be compared with a given operator only if the operator can be applied to each value in the respective tuples. For example, as demonstrated in the code below, you can compare two tuples of type (String, Int)
because both String
and Int
values can be compared using the <
operator. In contrast, two tuples of type (String, Bool)
can’t be compared with the <
operator because the <
operator can’t be applied to Bool
values.
("blue", -1) < ("purple", 1) // OK, evaluates to true
("blue", false) < ("purple", true) // Error because < can't compare Boolean values
Ternary Conditional Operator
The ternary conditional operator is a special operator with three parts, which takes the form question ? answer1 : answer2
. It’s a shortcut for evaluating one of two expressions based on whether question
is true or false. If question
is true, it evaluates answer1
and returns its value; otherwise, it evaluates answer2
and returns its value.
The ternary conditional operator is shorthand for the code below:
if question {
answer1
} else {
answer2
}
Here’s an example, which calculates the height for a table row. The row height should be 50 points taller than the content height if the row has a header, and 20 points taller if the row doesn’t have a header:
let contentHeight = 40
let hasHeader = true
let rowHeight = contentHeight + (hasHeader ? 50 : 20)
// rowHeight is equal to 90
The preceding example is shorthand for the code below:
let contentHeight = 40
let hasHeader = true
let rowHeight: Int
if hasHeader {
rowHeight = contentHeight + 50
} else {
rowHeight = contentHeight + 20
}
// rowHeight is equal to 90
The first example’s use of the ternary conditional operator means that rowHeight
can be set to the correct value on a single line of code, which is more concise than the code used in the second example.
The ternary conditional operator provides an efficient shorthand for deciding which of two expressions to consider. Use the ternary conditional operator with care, however. Its conciseness can lead to hard-to-read code if overused. Avoid combining multiple instances of the ternary conditional operator into one compound statement.
Nil-Coalescing Operator
The nil-coalescing operator (a ?? b
) unwraps an optional a
if it contains a value, or returns a default value b
if a
is nil
. The expression a
is always of an optional type. The expression b
must match the type that is stored inside a
.
The nil-coalescing operator is shorthand for the code below:
a != nil ? a! : b
The code above uses the ternary conditional operator and forced unwrapping (a!
) to access the value wrapped inside a
when a
is not nil
, and to return b
otherwise. The nil-coalescing operator provides a more elegant way to encapsulate this conditional checking and unwrapping in a concise and readable form.
The example below uses the nil-coalescing operator to choose between a default color name and an optional user-defined color name:
let defaultColorName = "red"
var userDefinedColorName: String? // defaults to nil
var colorNameToUse = userDefinedColorName ?? defaultColorName
// userDefinedColorName is nil, so colorNameToUse is set to the default of "red"
The userDefinedColorName
variable is defined as an optional String
, with a default value of nil
. Because userDefinedColorName
is of an optional type, you can use the nil-coalescing operator to consider its value. In the example above, the operator is used to determine an initial value for a String
variable called colorNameToUse
. Because userDefinedColorName
is nil
, the expression userDefinedColorName ?? defaultColorName
returns the value of defaultColorName
, or "red"
.
If you assign a non-nil
value to userDefinedColorName
and perform the nil-coalescing operator check again, the value wrapped inside userDefinedColorName
is used instead of the default:
userDefinedColorName = "green"
colorNameToUse = userDefinedColorName ?? defaultColorName
// userDefinedColorName is not nil, so colorNameToUse is set to "green"
Range Operators
Swift includes several range operators, which are shortcuts for expressing a range of values.
Closed Range Operator
The closed range operator (a...b
) defines a range that runs from a
to b
, and includes the values a
and b
. The value of a
must not be greater than b
.
The closed range operator is useful when iterating over a range in which you want all of the values to be used, such as with a for
-in
loop:
for index in 1...5 {
print("\(index) times 5 is \(index * 5)")
}
// 1 times 5 is 5
// 2 times 5 is 10
// 3 times 5 is 15
// 4 times 5 is 20
// 5 times 5 is 25
For more on for
-in
loops, see Control Flow.
Half-Open Range Operator
The half-open range operator (a..<b
) defines a range that runs from a
to b
, but doesn’t include b
. It’s said to be half-open because it contains its first value, but not its final value. As with the closed range operator, the value of a
must not be greater than b
. If the value of a
is equal to b
, then the resulting range will be empty.
Half-open ranges are particularly useful when you work with zero-based lists such as arrays, where it’s useful to count up to (but not including) the length of the list:
let names = ["Anna", "Alex", "Brian", "Jack"]
let count = names.count
for i in 0..<count {
print("Person \(i + 1) is called \(names[i])")
}
// Person 1 is called Anna
// Person 2 is called Alex
// Person 3 is called Brian
// Person 4 is called Jack
Note that the array contains four items, but 0..<count
only counts as far as 3
(the index of the last item in the array), because it’s a half-open range. For more on arrays, see Arrays.
One-Sided Ranges
The closed range operator has an alternative form for ranges that continue as far as possible in one direction—for example, a range that includes all the elements of an array from index 2 to the end of the array. In these cases, you can omit the value from one side of the range operator. This kind of range is called a one-sided range because the operator has a value on only one side. For example:
for name in names[2...] {
print(name)
}
// Brian
// Jack
for name in names[...2] {
print(name)
}
// Anna
// Alex
// Brian
The half-open range operator also has a one-sided form that’s written with only its final value. Just like when you include a value on both sides, the final value isn’t part of the range. For example:
for name in names[..<2] {
print(name)
}
// Anna
// Alex
One-sided ranges can be used in other contexts, not just in subscripts. You can’t iterate over a one-sided range that omits a first value, because it isn’t clear where iteration should begin. You can iterate over a one-sided range that omits its final value; however, because the range continues indefinitely, make sure you add an explicit end condition for the loop. You can also check whether a one-sided range contains a particular value, as shown in the code below.
let range = ...5
range.contains(7) // false
range.contains(4) // true
range.contains(-1) // true
Logical Operators
Logical operators modify or combine the Boolean logic values true
and false
. Swift supports the three standard logical operators found in C-based languages:
Logical NOT (
!a
)Logical AND (
a && b
)Logical OR (
a || b
)
Logical NOT Operator
The logical NOT operator (!a
) inverts a Boolean value so that true
becomes false
, and false
becomes true
.
The logical NOT operator is a prefix operator, and appears immediately before the value it operates on, without any white space. It can be read as “not a
”, as seen in the following example:
let allowedEntry = false
if !allowedEntry {
print("ACCESS DENIED")
}
// Prints "ACCESS DENIED"
The phrase if !allowedEntry
can be read as “if not allowed entry.” The subsequent line is only executed if “not allowed entry” is true; that is, if allowedEntry
is false
.
As in this example, careful choice of Boolean constant and variable names can help to keep code readable and concise, while avoiding double negatives or confusing logic statements.
Logical AND Operator
The logical AND operator (a && b
) creates logical expressions where both values must be true
for the overall expression to also be true
.
If either value is false
, the overall expression will also be false
. In fact, if the first value is false
, the second value won’t even be evaluated, because it can’t possibly make the overall expression equate to true
. This is known as short-circuit evaluation.
This example considers two Bool
values and only allows access if both values are true
:
let enteredDoorCode = true
let passedRetinaScan = false
if enteredDoorCode && passedRetinaScan {
print("Welcome!")
} else {
print("ACCESS DENIED")
}
// Prints "ACCESS DENIED"
Logical OR Operator
The logical OR operator (a || b
) is an infix operator made from two adjacent pipe characters. You use it to create logical expressions in which only one of the two values has to be true
for the overall expression to be true
.
Like the Logical AND operator above, the Logical OR operator uses short-circuit evaluation to consider its expressions. If the left side of a Logical OR expression is true
, the right side is not evaluated, because it can’t change the outcome of the overall expression.
In the example below, the first Bool
value (hasDoorKey
) is false
, but the second value (knowsOverridePassword
) is true
. Because one value is true
, the overall expression also evaluates to true
, and access is allowed:
let hasDoorKey = false
let knowsOverridePassword = true
if hasDoorKey || knowsOverridePassword {
print("Welcome!")
} else {
print("ACCESS DENIED")
}
// Prints "Welcome!"
Combining Logical Operators
You can combine multiple logical operators to create longer compound expressions:
if enteredDoorCode && passedRetinaScan || hasDoorKey || knowsOverridePassword {
print("Welcome!")
} else {
print("ACCESS DENIED")
}
// Prints "Welcome!"
This example uses multiple &&
and ||
operators to create a longer compound expression. However, the &&
and ||
operators still operate on only two values, so this is actually three smaller expressions chained together. The example can be read as:
If we’ve entered the correct door code and passed the retina scan, or if we have a valid door key, or if we know the emergency override password, then allow access.
Based on the values of enteredDoorCode
, passedRetinaScan
, and hasDoorKey
, the first two subexpressions are false
. However, the emergency override password is known, so the overall compound expression still evaluates to true
.
Explicit Parentheses
It’s sometimes useful to include parentheses when they’re not strictly needed, to make the intention of a complex expression easier to read. In the door access example above, it’s useful to add parentheses around the first part of the compound expression to make its intent explicit:
if (enteredDoorCode && passedRetinaScan) || hasDoorKey || knowsOverridePassword {
print("Welcome!")
} else {
print("ACCESS DENIED")
}
// Prints "Welcome!"
The parentheses make it clear that the first two values are considered as part of a separate possible state in the overall logic. The output of the compound expression doesn’t change, but the overall intention is clearer to the reader. Readability is always preferred over brevity; use parentheses where they help to make your intentions clear.
Copyright © 2017 Apple Inc. All rights reserved. Terms of Use | Privacy Policy | Updated: 2017-09-19


Title: Snow on the sidewalks Date: 2018-01-04T11:45:00Z-4:00 Category: Policy, Snow Tags: snow, sidewalks, policies
We had an interesting dicsussion at our select board meeting this week about clearing snow from the sidewalks. The question asked was, why would we pay so much to put in nice sidewalks only to leave them essentially un-passable in the winter? Unfortunately the many of the board and municipal officer’s answers seemed unsatisfying to the public attendees of the meeting. Here’s my take, and recognize that this is just my opinion. If people realy want sidewalks cleared in the winter, we can add it to the budget for next year, but hear me out first.
A few quick bullet points:
- Most area towns either have more sidewalk traffic, or require property owners to maintain clear sidewalks
- A policy requiring property owners to clear sidewalks would very easily become onerous, esp. for folks with lots of sidewalk on Main and Court streets
- We pay approx. $60,000 to clear roads each year; just clearing downtown sidewalks could easily add half again as much or more to our snow clearing budget
- Finally, once you set the precedent of clearing sidewalks, they must always be completely passable, leading the escalation of costs
These points have all come up before, or so it was explained to me by people who’ve been around municipal issues for a while. The biggest problem Castine has is not having sufficient pedestrian traffic to justify the expense of municipal snow clearing of sidewalks. Simply driving the plow of the sidewalks could lead to damage, and a specialty sidewalk clearing machine would need a place to put the snow.
All that said, I agree with the public at our last board meeting, we should have clearer sidewalks, if for no other reason than public safety. But how to achieve that, while not adding to our municipal budget? I wonder if there’s a public-private partnership where the town could agree to proivde a salt-sand bucket but set a policy of requiring downtown business to clear their sidewalks within 24-hours of a storm? I’m not sure how to give that policy teeth except for a financial penalty, but that seems like it would be harder on seasonal businesses than year round. Could the town agree to pay a small amount into a shovelling assistance fund managed by the Merchant’s Association?
I think this approach of a policy requiring business to clear sidewalks but providing a small amount of funds, say $5,000 to a fund each year to the Merchant’s would be the most sustainable method. It absolves the town of having to maintain perfectly clear sidewalks all year, while allowing those businesses for whom because of age or fiscal issues would see clearing sidewalks as a hardship to have some relief. What do you think? I’d love to hear your opnions. Click the facebook link to the left and drop me a comment, or email me at selectperson.colin@gmail.com


@@include('../layouts/head.html', { "title": "offer-01" }) @@include('../layouts/styles.html')
or sign in with facebook?
I agree with the terms and conditions and privacy policy and consent to being contacted by competition's host, its clients and(or) sponsors.


by Steve Kerr & Julian Kath
Workshop Tutorial for Intro to Data Science, taught by Simon Munzert
Hertie School, Berlin


Los Altos Hills Youth Commission
Enfranchising the Youth of Los Altos Hills
The Los Altos Hills Youth Commission (LAHYC) is a group of Los Altos Hills teens who seek to enfranchise the youth of the area by providing them with an opportunity to connect with one another. We regularly host events to foster interaction and build connections. In addition, the LAHYC regularly volunteers at Los Altos Hills events. Over the course of the year, the Los Altos Hills Youth Commission holds 3 main events (The Monster Bash, The Leadership Conference, and The Movie Night) to help local teens meet activist, entrepreneurs, and other teens in the area.
How Do I Join?
Look at the Admissions Process!
What Do We Do?
See our Mission Statement!
What's Going On?
Visit our Blog!


energy_ops module¶
-
energy_ops.
energy_inner_pjkpmn
(j, k, m, n, lam=array([1]))[source]¶ Calculates energy inner product between monomials P_{j,k} and P_{m, n}. Uses the Gauss-Green formula so that
- <P_{j,k}, P_{m,n}>_energy = <P_{j,k}, P_{m,n}>_L2 - lam*<P_{j-1,k}, P_{m,n}>_L2
lam*sum_V0{P_{m,n}*d_n(P_{j,k})}
- Parameters
k, m, n (j,) – Represent monomial indices P_{j,k} and P_{m, n}
lam – represents weight given to the energy part of the inner product
- Returns
<P_{j,k}, P_{m,n}>_energy
-
energy_ops.
generate_energy_ops
(n, k, normalized=False, lam=array([1]), frac=True)[source]¶ - Generates orthogonal polynomials with respect to the energy inner product. The Gram-Schmidt algorithm
is implemented here.
- Parameters
n – Maximum degree of orthogonal polynomial.
k – family of monomials to use in Gram-Schmidt (k = 1, 2, or 3)
normalized – Boolean representing whether the resulting polynomials should be normalized or monic.
lam – np.array of lambda values for the generalized Sobolev inner product. The default value is 1 (corresponding to the regular Sobolev inner product). If lam = np.array([0]), this is the L2 inner product.
frac – Boolean representing whether the coefficients should remain as fractions or should be
to floating point numbers at the end of all calculations. (converted) –
- Returns
- np.array of coefficients of the orthogonal polynomials with
respect to the basis {P_0k, P_1k,…, P_nk}. Each row in this array is a polynomial, and there are n+1 rows and n+1 columns. If normalized is True, the polynomials will be normalized. Otherwise, the polynomials will be monic. If normalized is True, frac must be False to obtain normalized coefficients.


Company profile - Canadian Company Capabilities
Third-Party Information Liability Disclaimer
Some of the information on this Web page has been provided by external sources. The Government of Canada is not responsible for the accuracy, reliability or currency of the information supplied by external sources. Users wishing to rely upon this information should consult directly with the source of the information. Content provided by external sources is not subject to official languages, privacy and accessibility requirements.
JustIt Solution Inc.
Mailing Address:
20-2020 South MillwayMISSISSAUGA, Ontario
L5L 1K2
Location Address:
20-2020 South MillwayMISSISSAUGA, Ontario
L5L 1K2
Tel.:<PHONE_NUMBER>
Fax:
Logo
Company Profile
JustIT Solution is a computer technology and consulting corporation headquartered in Mississauga, Ontario, Canada.
JustIT Solution is a qualified Supplier of IT consulting services to the Governments of Canada and Ontario. The company was awarded the Vendor of Record and Preferred Supplier statuses under the following government arrangements during the last few years:
- ProServices, Supply Arrangements - E60ZT-120001/080/ZT
- TBIPS, Standing Offers - EN578-120158/391/EI (as RightIT Venture member)
- TBIPS, Supply Arrangements - EN578-055605/691/EI (as RightIT Venture member)
- OSS-00430429 - Task-based I&IT Services
- OSS-00461242 - I&IT Solutions Consulting Services
- OSS-00426611 - Management Consulting Services
Full profile
Full profile
Contact information
Company description
541612 - Human Resources Consulting Services
Product / Service / Licensing
- ProServices, Supply Arrangements - E60ZT-120001/080/ZT
- TBIPS, Standing Offers - EN578-120158/391/EI (as RightIT Venture member)
- TBIPS, Supply Arrangements - EN578-055605/691/EI (as RightIT Venture member)
- OSS-00430429 - Task-based I&IT Services
- OSS-00461242 - I&IT Solutions Consulting Services
- OSS-00426611 - Management Consulting Services
JustIT Solution provides professional resources of all experience levels for the following service categories and roles:
Ontario’s qualifications
--------------------------
Service Categories:
ARCHITECTURE
SOLUTIONS DEVELOPMENT
TESTING and QA
DEPLOYMENT and OPERATIONS
INFORMATION MANAGEMENT
ORACLE PEOPLESOFT HCM/ERP APPLICATION ENVIRONMENT
Roles:
Applications Architect
Business Analyst
Business Architect
Business Integration Specialist
Business Intelligence Specialist
Data Analytical Specialist/Scientist
Data Architect / Modeller
Data Conversion Specialist
Database Administrator
Financial Analyst
Information Architect
Information Management Specialist
Infrastructure Integration Specialist (Network)
Infrastructure Integration Specialist (Server)
Methodology Specialist
Middleware Specialist
PCI Security Specialist
Privacy Impact Assessment (PIA) Specialist
Programmer / Developer
Project Manager / Leader
Security Architect
Security Specialist
Software Specialist
Solutions Designer
Systems Administration / Operation Support Specialist
Systems Analyst
Systems Testing / QA Specialist
Task-based Consultant
Technical Writer
Technology Architect
Technology Infrastructure Support Specialist
Telecommunications Architect/Engineer
Training Specialist
Web Specialist
Canada’s qualifications
--------------------------
Service Streams:
APPLICATIONS SERVICES
IM/IT SERVICES
BUSINESS SERVICES
PROJECT MANAGEMENT SERVICES(IT and Non-IT)
Roles:
Application / Software Architect
Business Analyst
Business Consultant
Business System Analyst
Data Conversion Specialist
Database Administrator
Database Analyst
Database Modeller/IM Modeller
ERP Functional Analyst
ERP Programmer Analyst
ERP System Analyst
IM Architect
Network Analyst
Platform Analyst
Programmer / Analyst
Programmer / Software Developer
Project Leader
Project Manager
Quality Assurance Specialist/Analyst
Storage Architect
System Administrator
System Analyst
System Analyst
Technical Architect
Technology Architect
Tester
WEB Architect
WEB Designer
WEB Developer
Web Graphics Designer
Web Multi-media Content Consultant
Webmaster
D302-ADP Systems Development Services
D306-ADP Systems Analysis Services
D308-Programming Services
D311-ADP Data Conversion Services
R201-Civilian Personnel Recruitment (incl. Services of Employment Agencies)
Sector information
Classification codes
Unique applications:
resumeGen - web-based universal resume management system: www.resumeGen.comresumeGen allows the customer to build and automatically synchronize multiple versions of a personal resume, generate various presentation shapes and download final result in different data formats.
lightDMS - Lightweight Document Management Solution
lightDMS is a lightweight document management framework for web-based applications.
g2c - Cloud storage gateway solution
g2c is an unified interface to multiple vendor clouds.
JustHr - HR Management Portal: www.justHrPortal.com
JustHr Portal is the company in-house comprehensive human resource application for managing our consulting resources.
Key / Major clients:
• Treasury Board Secretariat, Ontario• Department of National Defence, Canada
• Ministry of Community and Social Services, Ontario
• Environment Canada
• Ministry of Labour, Ontario
• Ministry of Health and Long-Term Care, Ontario
• Ministry of Education, Ontario
• eHealth Ontario
• Ministry of the Environment and Climate Change, Ontario
• Ministry of Government and Consumer Services, Ontario
• Royal Bank of Canada
• Microsoft Canada
• Bloomberg, USA
Third-Party Information Liability Disclaimer
Some of the information on this Web page has been provided by external sources. The Government of Canada is not responsible for the accuracy, reliability or currency of the information supplied by external sources. Users wishing to rely upon this information should consult directly with the source of the information. Content provided by external sources is not subject to official languages, privacy and accessibility requirements.
Contacts
Contact information
Description
Company description
541612 - Human Resources Consulting Services
Products, services and licensing
Product / Service / Licensing
- ProServices, Supply Arrangements - E60ZT-120001/080/ZT
- TBIPS, Standing Offers - EN578-120158/391/EI (as RightIT Venture member)
- TBIPS, Supply Arrangements - EN578-055605/691/EI (as RightIT Venture member)
- OSS-00430429 - Task-based I&IT Services
- OSS-00461242 - I&IT Solutions Consulting Services
- OSS-00426611 - Management Consulting Services
JustIT Solution provides professional resources of all experience levels for the following service categories and roles:
Ontario’s qualifications
--------------------------
Service Categories:
ARCHITECTURE
SOLUTIONS DEVELOPMENT
TESTING and QA
DEPLOYMENT and OPERATIONS
INFORMATION MANAGEMENT
ORACLE PEOPLESOFT HCM/ERP APPLICATION ENVIRONMENT
Roles:
Applications Architect
Business Analyst
Business Architect
Business Integration Specialist
Business Intelligence Specialist
Data Analytical Specialist/Scientist
Data Architect / Modeller
Data Conversion Specialist
Database Administrator
Financial Analyst
Information Architect
Information Management Specialist
Infrastructure Integration Specialist (Network)
Infrastructure Integration Specialist (Server)
Methodology Specialist
Middleware Specialist
PCI Security Specialist
Privacy Impact Assessment (PIA) Specialist
Programmer / Developer
Project Manager / Leader
Security Architect
Security Specialist
Software Specialist
Solutions Designer
Systems Administration / Operation Support Specialist
Systems Analyst
Systems Testing / QA Specialist
Task-based Consultant
Technical Writer
Technology Architect
Technology Infrastructure Support Specialist
Telecommunications Architect/Engineer
Training Specialist
Web Specialist
Canada’s qualifications
--------------------------
Service Streams:
APPLICATIONS SERVICES
IM/IT SERVICES
BUSINESS SERVICES
PROJECT MANAGEMENT SERVICES(IT and Non-IT)
Roles:
Application / Software Architect
Business Analyst
Business Consultant
Business System Analyst
Data Conversion Specialist
Database Administrator
Database Analyst
Database Modeller/IM Modeller
ERP Functional Analyst
ERP Programmer Analyst
ERP System Analyst
IM Architect
Network Analyst
Platform Analyst
Programmer / Analyst
Programmer / Software Developer
Project Leader
Project Manager
Quality Assurance Specialist/Analyst
Storage Architect
System Administrator
System Analyst
System Analyst
Technical Architect
Technology Architect
Tester
WEB Architect
WEB Designer
WEB Developer
Web Graphics Designer
Web Multi-media Content Consultant
Webmaster
D302-ADP Systems Development Services
D306-ADP Systems Analysis Services
D308-Programming Services
D311-ADP Data Conversion Services
R201-Civilian Personnel Recruitment (incl. Services of Employment Agencies)
Sector
Sector information
Classification codes
Unique applications:
resumeGen - web-based universal resume management system: www.resumeGen.comresumeGen allows the customer to build and automatically synchronize multiple versions of a personal resume, generate various presentation shapes and download final result in different data formats.
lightDMS - Lightweight Document Management Solution
lightDMS is a lightweight document management framework for web-based applications.
g2c - Cloud storage gateway solution
g2c is an unified interface to multiple vendor clouds.
JustHr - HR Management Portal: www.justHrPortal.com
JustHr Portal is the company in-house comprehensive human resource application for managing our consulting resources.
Key / Major clients:
• Treasury Board Secretariat, Ontario• Department of National Defence, Canada
• Ministry of Community and Social Services, Ontario
• Environment Canada
• Ministry of Labour, Ontario
• Ministry of Health and Long-Term Care, Ontario
• Ministry of Education, Ontario
• eHealth Ontario
• Ministry of the Environment and Climate Change, Ontario
• Ministry of Government and Consumer Services, Ontario
• Royal Bank of Canada
• Microsoft Canada
• Bloomberg, USA


About
About 8th/26th Calder Valley Scouts
We meet at Central Methodist Church, Todmorden and have been in existence for over 50 years. We accept all Christian denominations and all religions or none. We do not attend regular church parades at Central, but we do support the RBL’s remembrance day and Veteran’s day parades. We also support Todmorden Gang Show, which has been running nearly as long as the Group!
The boys and girls in the Group do loads of activities around Todmorden and further afield. We have our own minibuses, which we use for camps and trips, and which are available for use by other community groups.
We welcome and encourage you to join us!


Local parsers
Local parsers reside in your browser. This allows to prototype and polish a parser quickly. Once the parser is complete, consider commiting it to GitHub.
Parsers from GitHub
Local templates
Local templates reside in your browser. This allows to prototype and polish a template quickly. Once the template is complete, consider commiting it to GitHub.
Templates from GitHub


Toggle navigation
Currency Exchange Rate Checker
Hello [[${#httpServletRequest.remoteUser}]]!
Admin
List of users
Username
Name
Password
Date of Birth
Email
Address
ZIP
Country
No user exit yet!
List of User Authorities
Username
Authority
No user authority exit yet!
List of Currencies
Name
Code
No currency exit yet!


|
cds
2.3.1
|
Array of Hazard Pointer guards. More...
#include <cds/gc/hp.h>
Data Structures | |
| struct | rebind |
Rebind array for other size Count2 . More... | |
Public Member Functions | |
| GuardArray () | |
Default ctor allocates Count hazard pointers. | |
| GuardArray (GuardArray &&)=delete | |
| Move ctor is prohibited. | |
| GuardArray & | operator= (GuardArray &&)=delete |
| Move assignment is prohibited. | |
| GuardArray (GuardArray const &)=delete | |
| Copy ctor is prohibited. | |
| GuardArray & | operator= (GuardArray const &)=delete |
| Copy assignment is prohibited. | |
| ~GuardArray () | |
| Frees allocated hazard pointers. | |
| template<typename T > | |
| T | protect (size_t nIndex, atomics::atomic< T > const &toGuard) |
Protects a pointer of type atomic<T*> More... | |
| template<typename T , class Func > | |
| T | protect (size_t nIndex, atomics::atomic< T > const &toGuard, Func f) |
Protects a pointer of type atomic<T*> More... | |
| template<typename T > | |
| T * | assign (size_t nIndex, T *p) |
Store to the slot nIndex . More... | |
| template<typename T , int BITMASK> | |
| T * | assign (size_t nIndex, cds::details::marked_ptr< T, BITMASK > p) |
Store marked pointer p to the guard. More... | |
| void | copy (size_t nIndex, Guard const &src) |
Copy guarded value from src guard to slot at index nIndex . | |
| void | copy (size_t nDestIndex, size_t nSrcIndex) |
Copy guarded value from slot nSrcIndex to the slot nDestIndex . | |
| void | clear (size_t nIndex) |
Clear value of the slot nIndex . | |
| template<typename T > | |
| T * | get (size_t nIndex) const |
Get current value of slot nIndex . | |
| guarded_pointer | get_native (size_t nIndex) const |
| Get native hazard pointer stored. | |
Static Public Member Functions | |
| static constexpr size_t | capacity () |
| Capacity of the guard array. | |
Static Public Attributes | |
| static constexpr const size_t | c_nCapacity = Count |
| Array capacity. | |
Array of Hazard Pointer guards.
The class is intended for allocating an array of hazard pointer guards. Template parameter Count
defines the size of the array.
|
inline |
Store to
the slot nIndex
.
The function equals to a simple assignment, no loop is performed.
|
inline |
Store marked pointer p
to the guard.
The function equals to a simple assignment of p.ptr()
, no loop is performed. Can be used for a marked pointer that cannot be changed concurrently.
|
inline |
Protects a pointer of type atomic<T*>
Return the value of toGuard
The function tries to load toGuard
and to store it to the slot nIndex
repeatedly until the guard's value equals toGuard
|
inline |
Protects a pointer of type atomic<T*>
Return the value of toGuard
The function tries to load toGuard
and to store it to the slot nIndex
repeatedly until the guard's value equals toGuard
The function is useful for intrusive containers when toGuard
is a node pointer that should be converted to a pointer to the value type before guarding. The parameter f
of type Func is a functor that makes this conversion:
Really, the result of f( toGuard.load())
is assigned to the hazard pointer.


jekyll-theme-citrix
Welcome to your new Jekyll theme! In this directory, you’ll find the files you need to be able to package up your theme into a gem. Put your layouts in _layouts
, your includes in _includes
and your sass in _sass
. To experiment with this code, add some sample content and run bundle exec jekyll serve
– this directory is setup just like a Jekyll site!
This Jekyll theme should be used for all Codeshare project documentation sites. It includes the standard look & feel for Citrix and should be easy to adapt to your internal project site.
Installation
Add this line to your Jekyll site’s Gemfile
:
gem "jekyll-theme-citrix"
And add this line to your Jekyll site’s _config.yml
:
theme: jekyll-theme-citrix
And then execute:
$ bundle
Or install it yourself as:
$ gem install jekyll-theme-citrix
Usage
TODO: Write usage instructions here. Describe your available layouts, includes, and/or sass.
Contributing
Bug reports and pull requests are welcome on the Codeshare Bitbucket at https://codeshare.ice.citrix.com/git/projects/SSB/repos/ssb-jekyll/browse. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the Contributor Covenant code of conduct.
Development
To set up your environment to develop this theme, run bundle install
.
 To test your theme, run bundle exec jekyll serve
and open your browser at http://localhost:4000
. This starts a Jekyll server using your theme. Add pages, documents, data, etc. like normal to test your theme’s contents. As you make modifications to your theme and to your content, your site will regenerate and you should see the changes in the browser after a refresh, just like normal.
When your theme is released, only the files in _layouts
, _includes
, and _sass
tracked with Git will be released.
License
The theme is available as open source under the terms of the MIT License.


Item:
Apple Watch Rose Gold Series 4
Price:
$500.00
Payment
Credit Card Number:
Card Holder Name:
Expiration Date:
CVC:


Our website Car Rental Management System is designed so as to be used by Car Rental Company specializing in renting cars as well as individuals who are willing to rent cars to customers. It is an online system through which customers can view available cars, register, view profile and book car for a limited period of time. Our website aim is to produce a web-based system that allow customer to register and reserve car online and for the company to effectively manage their car rental business. we also ease customers task whenever they need to rent a car.
If u have any queries mail us.


Graduate with an AS in Cybersecurity and currently attaining a BS in Computer Science at California State University of Monterey Bay. Goal-driven team player with an emphasis on software development in respect to SDLC principles. Experienced and trained in consuming (REST,HEX,TCP,UDP,JSON RPC,XML) sync and async API’s to create drivers that control devices and gather real time analytics of enterprise level IOT devices.


{{header}} {{nav.opaque}}
Update: Our pre-booked conference accommodation has now sold out. For alternative accommodation we recommend University Rooms. Look out for rooms at Wycliffe, Keble, Merifield, or Magdalen as these are good value and a short walk from the conference.
We have arranged to offer a limited number of discounted rooms at Lincoln College to conference attendees from £30 a night. These rooms are on Turl St in historic central Oxford, 15 minutes from the conference venue. They can only be booked through our website, when you register for the conference.
The room price does not include breakfast. There are many cafes on the walk to the conference venue which offer a reasonably priced cooked breakfast. We suggest the Turl St Kitchen, Brown's Cafe or Heroes. There are also branches of Tesco, Sainsbury's, Pret a Manger, Costa, McDonalds etc.
The address of the conference accommodation is:
Lincoln College, Turl Street, Oxford, OX1 3DR, United Kingdom


 Click the button to connect this application with your Twitter account.
Connect to Twitter


MAJOR. & Brandy Salute Cancer Survivors In Touching "Even More" Visual
The original version was released last year sans Brandy's vocals.
by Erika MarieEven More
MAJOR. Feat. Brandy
Editor Rating: HOTTTTT
User Rating: not feeling it - 25% (4)
MAJOR. opens the video for his Brandy-assisted single "Even More" by saying, "I'm so proud of you. You haven't quit. You won't quit 'cause we don't quit!" Although the track was originally shared on MAJOR.'s debut album of the same name in September 2018, the singer returns with the "Vocal Bible" to help him with this updated version.
The singers' vocals were accompanied only buy the strums of guitar and it perfectly complemented the simple, yet emotional, video was created in partnership with Susan G. Komen’s #CancerAintMyName campaign. After adding Brandy to the track, "MAJOR. was then compelled to tribute the song in honor of Cancer Survivorship and the LOVE that fuels that fight to overcome," said the video's description.
"To every warrior in the struggle, please know you are NOT a burden," it continued. "The love from your village is EVEN MORE true. Cancer has many names, but it doesn’t have yours. #CancerAintMyName." Watch the video and let us know what you think.
Quotable Lyrics
When you wrap your arms around me, it feels like home
Love, you take away my lonely, not alone
Yes you are the very best thing and even better
One of many blessings when we're together