Our Projects
We want to generate unrivaled quality and value for our clients. Check out some of our previous work and get inspiration for your design project!. Feel free to download our Company Profile.
Modern Villas Buildings.
Proposed Design and Construction of Modern Villas buildings to be built at Oysterbay - Kindondoni Municipality in Dare es salaam.
Modern Office Building.
Proposed Design for Office building for Tanzania Investment Center (TIC) to be build at Dodoma Municipality in the Capital City of Tanzania.
Complex Commercial Building.
Proposed Design for Complex Commercial Building which will include Retail Shops, Shopping Malls, Office Spaces, Parking and Storage facilities to be built at DDC-Kariakoo in Dar es Salaam.
Modern Commercial Building.
Proposed Design Commercial Building which will include Retail Shops, Office Spaces to be built at Kibaha CBD Area in the Coast Region.
Modern Office Buildings.
Proposed Design for Office building for Tanzania Investment Center (TIC) to be build at Dodoma Municipality.
Modern Office Buildings.
Proposed Design for Office building for Tanzania Investment Center (TIC) to be build at Dodoma Municipality.
Modern Office Buildings.
Proposed Design for Office building for Tanzania Investment Center (TIC) to be build at Dodoma Municipality.
Modern Office Buildings.
Proposed Design for Office building for Tanzania Investment Center (TIC) to be build at Dodoma Municipality.


Braqueurs
Work-life balance breaks down for Paris's most gifted armed robbers when a grave mistake forces them to work for a crime boss in a high-stakes heist.


This is a community for all people to enjoy homegrown fruit and produce.
This is a person who grows their own fruit and would like to give it away to the community.
We would like this to become a community where we give and exchange. So, we encourage people to exchange for other produce that you grow at home. Also, if you have a fruit tree of some sort, it's nearly impossible to eat them all. Why not share?
Real, fresh, organic fruit is hard to come by. Even in our neighborhood markets nothing is as fresh and organic as the fruit being grown in our very own neighborhoods. Also, we encourage trading!
No, not at all! Any homegrown produce is encouraged!


Machine Learning in the Wild
I won’t be covering anything purely technical in this post, but I wanted to get some thoughts out there on what it takes to bring Machine Learning into production,
“Any sufficiently advanced technology is indistinguishable from magic.” - Arthur C. Clarke
This quote rings true today as much as the day that it was written. Especially when it comes to Machine Learning. I work with customers every day who are curious what this new magic called Machine Learning(ML) is and how they can apply it to a problem they’re facing. There’s no denying that ML is something that we should all be paying attention to but as we start to wade into the waters of ML, and discussing the process of framing the problem, testing our hypotheses, and bringing a system through to production we need to understand that this requires a bit of a shift in our traditional engineering process. In this post we will outline the general process that I’ve followed while helping customers move from idea/MVP to production.
Don’t start with Machine Learning
ML in undoubtedly changing the way we approach solving problems in the world today. More importantly, however, is knowing what problem it is that you’re trying to solve. Like many sciences and engineering discplines practitioners are looking to understand a problem domain in an effort to guide decision making processes. It’s this decision making process that is what we think about when approaching a problem. I want to highlight a few key questions one should ask about the problem at hand before rummaging through their toolboxes for an overpowered approach. Some of these key questions are as follows.
- What decision are we trying to make?
- Is there an existing decision making mechanism in place?
- Are we trying to replace this decision making mechanism?
- Who is this decision impacting?
- What will the potential outcomes of this decision be?
- What properties of the system am I trying to capture?
- Do we have domain experts involved?
- Do we have the right domain experts invoved?
None of the questions I’ve provided have anything to do with Machine Learning directly. Rather, they’re asked to help guide the process of applying ML and measuring it’s utility in a given problem domain. These types of questions will help you scope the problem you’re working on and provide a certain acceptance criteria.
Data and the system generating it
Once we have a thorough understanding of the problem that we’re trying to apply ML to, and we understand what decision it is that we’re trying to make / replace, we can start to investigate what data that system generates. Many of the customers I’ve worked with think about this process as just the ML oriented questions around the types of features, what types of random variables they are, what classes we may want to define for a supervised learning problem, etc. We also need to understand questions not directly related to the data generating system, itself. Questions around data collection, storage, access, governance, provenance, etc. Questions like :
- How is the data being collected?
- What steps are being taken to validate the data collection mechanisms?
- How reliable are the measurements being collected?
- Where is the data being persisted?
- What controls are in place to manage access to this data?
- How is this data being versioned?
These questions will influence the success of your ML project, overall. Without data, we’re left without the ability to use this powerful new technology.
Deliverying Production Grade Software
The next step in the adoption of ML is understanding not just what software is, how to write it, and how to use an SCM system to manage releases, but one also needs to understand what running software in production entails. Anyone who has been part of the industry for any length of time in the last 5 to 7 years has heard the term DevOps before. This term is just a blend of the terms Development and Operations and the concept of blending the two words captures the idea of minimizing the distance between the two general concepts. What it means to be a developer on a production level system requires a thorough understanding of not only the code base, but the properties and characteristics of our production grade systems and what the upper and lower bounds are on the performance of our systems.
You may have also heard the term machine learning engineer used within industry, as well. This new title and role is a result of the differences, yet seemingly similar, approaches needed to move from experimentation to production in ML systems. Some of the things to think about involve both the data acquisition, and machine learning (training and serving) pipelines.
- What does testing look like for our pipelines, end to end?
- How do we perform validation of performance of our system (not just the model)?
- How can we provide tooling to measure for concept drift?
- How can we qualify acceptable throughput of our system, end to end?
Now for Machine Learning
Now that we have a thorough understanding of the problem domain, use case, data generating system, and all of the software required to stand a system up in production we can start to loop back to the opening thoughts of this post. We need to understand what methods we might be able to use to describe the phenomenon that we’re trying to capture. Typically in Machine Learning by describe, we mean capturing the variance of the overall system in a way that we can use to ultimately make decisions.
In order to understand how we can apply ML, in production, we need to understand everything outlined above because it will impact the choices we make from a modeling perspective. Anecdotally we don’t want to make the decision of using a non-parametric model in a given problem domain where the datasets might be growing rapidly. A concrete example of a use case that I’ve run into in this effect has been modeling data networking traffic characteristics. The rate at which data is generated and collected depends on the number of devices sending information over a network. With the types of connectivity we see today this can quickly become a show stopper from moving a model into production, especially if we have to layer feature engineering into the pipeline, on the fly, as well. A non-parametric model will quickly run out of resources in terms of computational and/or time, depending on the problem domain.
Understanding the use case, the decisions we’re trying to make, what mechanisms are in place to collect and persist the data that our system is generating, and the software tooling and ecosystems required to put pipelines into production are imperative to providing a seamless experience of applying Machine Learning in the real world.
End-to-end Throughput
Last but not least after all of the steps outlined above are thoroughly understood we can start to provide the engineering guarantees we’re used to in the technology world. Anyone who has heard the term speeds and feeds understand that we’re talking about the end-to-end throughput of an entire tech stack, from start to finish. Once we are able to effectively measure all of the components of our ML system we can then identify bottle necks and work to alleviate them in a measureable and defensible way.
Overall, deploying Machine Learning in production may start out as feeling orthogonal to the traditional software engineering methodologies, but once an organization works through a few proof of concept or minimum viable product efforts, they will then understand what it takes to provide a meaningful end-to-end experience for using this new magic called Machine Learning.


20 People Who’ve Mastered Their Problem-Solving Skills
We’re constantly facing annoying situations in our daily lives. Some of us find these situations frustrating, while others look at them as opportunities to think outside the box and find creative solutions.
We at Bright Side were really dazzled with some of these creative geniuses and we’re pretty sure that there isn’t a problem these people can’t fix. Don’t believe us? Just take a look at the photos below.
1. That’s one way to charge your phone.
2. Art can be found in any form.
3. Well, it does get the job done...
4. When you can’t find a candle holder you have to improvise.
5. No plate? No problem.
6. No flat-screen TV? Still no problem.
7. This is actually pretty smart.
8. Just keep in mind that if you pull the sword from shifter, you won’t become the new King of England... unfortunately.
9. When you’re trying to reach your deadline at work:
10. Moms really do have the answer for everything.
11. How artists deal with scrapes:
12. An apple a day keeps the tent from flying away.
13. Lazy or brilliant parenting skills?
14. Car inside of a car... car-ception.
15. This is how you properly clean your windshield in the winter.
16. When your wife is too jealous:
17. The morning after you drunkenly visit a Taco Bell...
18.
19. Fixed it... kinda.
20. You gotta admit that that’s pretty clever.
Were you impressed with the ingenuity behind these problem-solving gems? Which of these solutions do you find to be the most remarkable? Share your thoughts in the comments below.
Preview photo credit eren_savas / Twitter


Fierce Planet is an open source toolkit for developing agent-based models, with a focus on urban and social simulations.
It runs on Node.js on the server, and uses Three.js extensively to generate 3D simulations in the browser. Click here to check your browser is compatible.
For more information, please visit:
To run Fierce Planet locally:
cd fp npm install gulp dist node app.js
In addition, a number of other commands can be run using gulp:
To generate code documentation, run:
gulp require
To generate code documentation, run:
gulp jsdoc
To convert the HTML website content from the Markdown docs:
gulp pandoc-site
A small amount of code currently uses ES6 for convenience. To convert this code to ES5, run:
gulp babel-shader
The code includes the following


BOXING HELENA A Film Review Copyright Dragan Antulov 1999
One of the indicator of badness in film is the hype being remembered more than film itself. Such was the case with BOXING HELENA, 1993 directorial debut of Jennifer Chambers Lynch, daughter of the great David Lynch. Made in the dying years of post-TWIN PEAKS Lynch craze among movie snobs, it was hyped as another, "warped, twisted masterpiece" of Lynch clan. Kim Basinger also provided extra publicity by quitting the lead role and being sued for the breech of contract. But, the result was extremely disappointing film, which quickly sank into well-deserved oblivion.
The movie protagonist is Nick Cavanaugh (played by Julian Sands), talented surgeon who is getting obsessed by Helena (Sherilyn Fenn), beautiful woman who ditched him after brief affair. Cavanaugh stalks her and uses every opportunity for the pathetic attempts to re-establish the relationship. During one of such occasions, Helena is hit by a car, and Nick quickly takes the role of her personal physician in order to have his way with her. After she wakes up, Helena discovers not only that she is prisoner in Cavanaugh's stylish residence, but also that Cavanaugh amputated her legs in order to prevent her from escaping. She is still trying to escape, so Cavanaugh takes off her arms.
Apart from casting Sherilyn Fenn (Audrey Horne in TWIN PEAKS and small cameo in WILD AT HEART) and the use of twisted characters and their perverse fantasies, this film by Ms. Lynch hasn't got anything in common with the works of director's more talented father. Despite rather bizarre subject, the style of this film is conventional and setting is light, characters are beautiful - but the result at the end is quite sterile and the film in the end looks too artificial for dark sexual fantasy it was supposed to portray. Jennifer Lynch obviously lacks talents in directing and it becomes painfully obvious in the scenes that are supposed to erotic - its banal artificiality is even bellow the standards of Playboy videos. The actors aren't good either. Julian Sands is terribly miscast as emotionally disturbed man - this actors is best either when he plays charismatic protagonists or villains; being neurotic doesn't suit him. Bill Paxton was better for this role, but his presence was wasted in forgettable and unnecessary subplot dealing with Helena's boyfriend. Sherilyn Fenn contributed to this film mostly by her looks, but even the her greater effort in acting couldn't help this film. The screenplay, on the other hand, is awful, at least for someone who had made best-seller with Laura Palmer's diary - the events in this movie are implausible, characters come and go without purpose and many unnecessary subplots only slow down the film and add to the total confusion. One of those subplots involves character of Cavanaugh's "regular" girlfriend, played by Betsy Clarke. The twist at the end, although unpredictable, is unbelievable and the viewers, who had the stomach to endure entire film, would feel cheated. All in all, BOXING HELENA is disorganised quasi-artistic mess of a movie that should be remembered as nothing more than one of the wiser decisions in Kim Basinger's career.
RATING: 2/10 (-)
Review written on April 24th 1999
-- Dragan Antulov a.k.a. Drax Fido: 2:381/100 E-mail<EMAIL_ADDRESS>E-mail<EMAIL_ADDRESS>E-mail<EMAIL_ADDRESS>The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Contact Us
Home
Bay of Islands
Rotorua
Fjordland
Example headline
First Name:
Last Name:
I am awesome
Please spam me:
YES!
NO!
MAYBE, SOMETIMES!


Tiltfile API Reference¶
-
class
api.
Blob
¶ The result of executing a command on your local system
-
class
api.
LocalPath
¶ A path on disk
-
api.
docker_build
(ref, context, build_args={}, dockerfile='Dockerfile')¶ Builds a docker image. :type ref:
str
:param ref: e.g. a blorgdev/backend or gcr.io/project-name/bucket-name :type context:str
:param context: The path to use as the Docker build context. :type build_args:Dict
[str
,str
] :param build_args: the build-time variables that are accessed like regular environment variables in theRUN
instruction of the Dockerfile. See the Docker Build Arg documentation :type dockerfile:str
:param dockerfile: The path to a DockerfileReturn type: None
-
api.
fast_build
(img_name, dockerfile_path, entrypoint='')¶ Initiates a docker image build that supports
add
s andrun
s, and that uses a cache for subsequent builds.See the fast build documentation.
Return type: FastBuild
-
api.
k8s_resource
(name, yaml='', image='', port_forwards=[])¶ Creates a kubernetes resource that tilt can deploy using the specified image.
Parameters: - name (
str
) – What call this resource in the UI - yaml (
Union
[str
,Blob
]) – Optional YAML. If YAML, as a string or Blob is not passed we expect to be able to extract it from an existing resource. - image (
str
) – An optional Image. If the image is not passed, we expect to be able to extract it from an existing resource. - port_forwards (
Union
[str
,int
,List
[int
]]) – Local ports to connect to the pod. If no target port is specified, will use the first container port. Example values: 9000 (connect localhost:9000 to the default container port), ‘9000:8000’ (connect localhost:9000 to the container port 8000), [‘9000:8000’, ‘9001:8001’] (connect localhost:9000 and :9001 to the container ports 8000 and 8001, respectively).
Return type: None
- name (
-
api.
k8s_yaml
(yaml)¶ Call this with a path to a file that contains YAML, or with a
Blob
of YAML.We will infer what (if any) of the k8s resources defined in your YAML correspond to Images defined elsewhere in your
Tiltfile
(matching based on the DockerImage ref and on pod selectors). Any remaining YAML is YAML that Tilt applies to your k8s cluster independently.Parameters: yaml ( Union
[str
,List
[str
],LocalPath
,Blob
]) – Path(s) to YAML or YAML as aBlob
.Return type: None
-
api.
kustomize
(pathToDir)¶ Run kustomize on a given directory and return the resulting YAML as a Blob
Return type: Blob
-
api.
local_git_repo
(path)¶ Creates a
repo
from the git repo atpath
.Return type: Repo


---
layout:post
categories:toeza
tags:toeza
title:How to Play Clock Patience
date:2016-12-07 14:32:45 +0800
---
Edit Article
How to Play Clock Patience
Three Parts:Setting Up the TableauPlaying Through the DeckWinning the GameCommunity Q&A
Clock Patience is a simple, fun variant of Solitaire. Like other versions of Solitaire, Clock Patience is played by one player with only one deck of cards. Unlike other games, however, it requires almost no strategy, and winning comes down to complete chance. To play Clock Patience, deal your cards, play through the deck, and learn how to win the game.
Steps
Part 1Setting Up the Tableau
1
Shuffle your pack of cards. Any standard set of cards will work for this game, so get a deck at the store or find one around the house. Count out your cards to make sure that you have all 52, otherwise you won't be able to win. Shuffle the deck and get ready to deal. Also consider playing online if you have a computer and an internet connection.[1]
2
Find a large, flat surface. Clock Patience requires a little more space than a traditional game of Solitaire.  You can also play clock patience on the floor if you need more space.
3
Begin dealing the cards. Clock Patience takes its name from the setup: the cards are arranged in 12 piles of four, positioned in a circle. Each of these 12 piles takes the position of a number on a clock: one pile for 12 o'clock, one pile for 1 o'clock, one pile for 2 o'clock, and so on. Deal the cards face down into their 12 piles around the circle until each pile has four cards.[2]
4
Place the remaining stack in the middle. Once you deal four cards into their 12 piles, you will have four cards remaining. These become their own 13th stack, placed facedown in the middle of the circle.[3]
Part 2Playing Through the Deck
1
Play the first card. The middle, or 13th pile has four cards: turn one of them over and place it on top of its stack. Look at the number or face-value of the card. The number or face will determine where the card goes.[4]
2
Move the card to its pile.  For face cards, place the Jacks in the 11 o'clock pile and Queens in the 12 o'clock pile. Kings will be placed in the middle, or 13th pile. When you find the correct pile, slide the card face up, under the stack it belongs in.
3
Turn over the next card. Turn over the top card of the pile you just played into. This becomes your next card in play. Place that card into the pile in which it belongs. For example, a 7 of diamonds would go facedown into the bottom of the 7 o'clock pile. A Queen of spades would go facedown at the bottom of the 12 o'clock pile.
4
Continue playing cards. For each card that you turn over and place in the correct pile, flip over the next card from that pile and play it. Clock patience is a fun game to play quickly, so try to place the cards as quickly as you determine where they belong. Continue playing until there are no cards to flip over.[5]
Part 3Winning the Game
1
Win by turning over all of the cards. If you flip over and play your last card, then find that all of the cards have successfully been placed into their piles, you win. All four Kings will be in the middle pile, all Jacks will be in the 11 o'clock pile, all sixes will be in the 6 o'clock and so on. Reshuffle your cards and play another hand.[6]
2
Lose by failing to turn over all the cards. If you get to the end of the game and you've exposed all four kings but other cards are still facedown, you lose the game. Clock Patience is entirely a game of chance, so don't be too frustrated. Shuffle your cards well and try again.[7]
3
Don't worry about strategy. Unlike other Solitaire variations, strategy doesn't factor into Clock Patience. The order and stacking of the cards is left entirely up to chance, affected only by the order in which they're dealt. In fact, you have a 1 in 13 chance of winning: the exact number of piles that you dealt.[8]


Resume
I have previously worked at international and national universities and for leading organisations in industry. You can download my full curriculum vitae as pdf.
Academic Positions
Assistant Professor of Information Systems
2022 - Now
University of Twente, The Netherlands
Research and teaching in people analytics and AI at work, and information management in the digital era.
PostDoc
2021 - 2022
University of Osnabrück, Germany
Research and teaching in data-driven economy and innovation in automotive, and business process management.
Research Associate
2017 - 2022
University of Münster, Germany
Research and teaching in virtual, distributed work, digital traces, and information management in the digital era.
Research Associate
2017
University of Hamburg, Germany
Research and teaching in information security management.
Visiting Positions
Visiting Scholar
2018
University of Sao Paulo, Brazil
Research in the analysis of community social networks based on complex modeling (with Odemir Bruno).
Visiting Scholar
2016
University of Sydney, Australia
Writing my master thesis on the topic of analysis of enterprise social media networks (with Kai Riemer).
Professional Positions
Software Engineer
2015 - 2017
AMCON GmbH, Cloppenburg, Germany
Conception and development of mobile and stationary passenger information systems for bus, train, and train stations.
Junior Software Engineer
2017 - 2018
BTC Business Technology Consulting AG, Oldenburg, Germany
Development and testing of SAP Human Resources, energy software solutions (Smart Grid), and mobile applications for retail.
Education
Ph.D in Information Systems
2017 - 2021
University of Münster, Germany
Research in virtual, distributed work, digital traces, and information management in the digital era.
M.Sc. in Information Systems
2015 - 2017
University of Münster, Germany
Taking specialization in advanced software development and information management.
B.Sc. in Information Systems & Fachinformatiker
2011 - 2015
IBS IT and Business School Oldenburg, Germany
Taking specialization in business administration and software development.


Q1Train & deploy your models with ML algorithms in Gramex. Enable user data entry through forms.
|
Q2Do everything in Gramex via the IDE. Build application UI via drag-and-drop.
|
Q3Apply pre-built ML models. Build data visualizations with narratives using drag-and-drop.
|
Q4Build data transfer flows using a UI. Convert designs into working code in 1-click.
|
|
|---|---|---|---|---|
Connectors |
||||
Processors |
Data model: DataOps framework to create ETL flows & operations via drag-and-drop. | |||
Models |
AI/ML API: ML Service lets you train and deploy machine learning models without code | ML Model: Insight Tree algo & app discovers biggest problem area. Top Cause app & algo finds biggest driver. | Charts: Design2Code lets you convert a chart screenshot into a working chart. | |
Visuals |
UI Components: Forms Builder creates embeddable forms via drag-and-drop | UI Components: UI Gallery lets you build a full-page scaffolding using pre-built widgets. |
Charts: Gramex Charts creates configurable charts via drag-and-drop.
D3 & Vega charts fully supported.
|
|
Stories |
Narratives: Narratives gallery has embeddable customizable rich text narratives that explain analyses. | |||
DevEx |
IDE: IDE covers all Gramex microservices Logging: Log Viewer includes widgets that can embed user analytics in any page. Access: Admin panel includes embeddable widgets and role management UI. |
IDE: Feature complete even for novice devs. Docs: App gallery to show you how to re-create 20 startups – in 1 hr each. |
Config: State management framework lets you share pages preserving user filters, selections & interactions |
Feature development will continue in all areas. These are the major developments.


The diagrams are in order from the entry rule to the last rule found
Please note this is the default template. You can make this more pretty but making your own templates.


During Phase 0, I asked a lot of questions. Probably 30% of my time spent typing was spent asking questions and looking for answers. The rest of the typing was for coding. I definitely learned a great deal about the importance of asking the good questions. But even good questions aren't always the 'right' questions. I would find that out through trial and error.
One thing I never did was post a question online. When a question came up, I needed the answer immediately. I couldn't afford to wait days for an answer. So all of my questions were directed at Google.
By asking questions in Google, I would often get a forum where someone posted a similar quesiton. Most of the time there was some example or problem they posted alone with it. I noticed that if they weren't specific enough, people wouldn't really understand what result they were looking for. This is especially true if there was nothing provided for a reference. For example, if I wanted to know how to get a value in a JavaScript array. I should mention whether it's in an object or not.
Even though I didn't post any questions on a forum, Google would often provide resources for the exact question I asked. So if I wasn't getting that result I wanted, I first went back and evaluated the question. There was a lot of face palm moments when I realized I should have included a key word...or my terminology was off.
So far my questions have been relatively basic and there has been no need to have someone look at my specific code. But I feel more than confident to successfully post future question to forums. Well that's not that hard. But being able to do it without being berated by a multitude of keyboard warriors can sometimes be challenging. And that, I can do.


{{value.productTitle}}
Easy Polo Black Edition
Please enter your email address and we'll send you instruction on how to reset your password.
dashboard.html


Orban ordered to apologise over 'misleading' Soros survey
by EUobserverHungary's top court ruled on Wednesday that nationalist prime minister Viktor Orban's government had published "misleading and falsely presented facts" about a refugee rights group in a questionnaire sent to millions of households in 2017. The NGO Hungarian Helsinki Committee said the Supreme Court ruled that the government had damaged its reputation over the "national consultation" questionnaire about US billionaire George Soros, ordered an apology and compensation of €6,000.


I am a computer enthusiast with computer skills,I good in both hardware and software but mostly in Windows operating system. Apart from that I am a great video editor with skill in both Adobe premier pro,after effects.I have interacted with Filmora,Sony vegas pro and even Davinci resolve,check my youtube channel there is a video I uploaded recently. Below are some of the things I enjoy and Love doing.


My personal thinking style is mostly concrete random, which means I am an experimenter. My perceptual quality is concrete so I register information directly through my five senses. My ordering ability is random, meaning I let my mind organize information by chunks, and in no particular order. It also enables me to skip steps in a procedure and still produce the desired result. My concrete random thinking style can be advantageous in DBC. I enjoy experimenting and going through the trial-and-error processes. I feel that this is one of best ways to learn to code. There is no abstract meaning behind code and it does what you tell it to do. Furthermore, my random ordering ability could prove to be beneficial if I can achieve the same result with less time. I recently read an article that is not directly related to web development, but it is indirectly related to many things in life, including web development. It explains that quantity should be your priority and not quality because quantity leads to higher quality. I can relate to this article as one keeps experimenting with code, he or she will learn what works and what doesn't and, over time, his or her findings and self-teachings will lead to well-written code. My biggest challenges come from learning to do something new entirely. For example, learning to use Git proved difficult as I never used it before. However, after repeating the commands many times, I am now proficient in using the basic commands. If you do something so many times, it will eventually click. I think I can expand the ways I learn and think by incorporating more step-by-step analysis more often. My mind tends to analyze information in chunks, but I know I can achieve same result faster if I organize my thoughts together.


Let us talk gaming. Let us know what and how you play!
How would you describe your gaming habit?
How many hours a week do you play games?
What is your favourite genre(s)? Select all that apply.
How often do you try games that differ from your norm?


Premium Mentoring by Sri Lankans for Sri Lankans
ScholarX Premium Mentoring
What is ScholarX?
ScholarX is an exclusive 3-month program aimed at providing mentoring support to a selected pool of High Potential undergraduate students based in Sri Lanka ideally by a Sri Lankan expat currently engaged with one of the world’s top universities or Fortune 500 companies. It’s our free premium mentoring platform by Sri Lankans for Sri Lankans working towards creating a culture of knowledge and expertise sharing without the limitation of geographical borders.
What is the duration of the program?
The program will require a 3-month commitment from both mentor and mentee. The number of meetings during this time will be up to the mentor and mentee to negotiate. However, based on past program effectiveness we recommend 12 meetings with the mentor.
What is the cost of the program?
ScholarX is a free program conducted by volunteer mentors who generously offer their time to support the next generation of change makers in Sri Lanka.
What topics are covered?
We acknowledge that each individual mentee is at a different stage of their career
and learning pathway. So we encourage both parties to have an open and honest
conversation to identify the direction and expertise required to customize their
mentoring. Topics past groups have requested include:
- Collaborating with the mentor on a project
- General career advice
- Higher study options to align with career path in academia or professional line of work.
How to be a ScholarX Mentee?
What are the eligibility requirements?
Our priority is given to applicants of Sri Lankan origin. However, if we have an excess of mentors, we will look at expanding the offering to foreign students as well.
- You must be atleast 18 years of age when you register
- You must currently be a full time or part-time student undertaking an undergraduate or postgraduate course.
- You have not already been accepted as a mentee in ScholarX more than once
What is the selection criteria?
We require all applicants to demonstrate, a high standard of English proficiency and a genuine curiosity to learn and innovate. In their responses, applicants must also show ambition to achieve their career goals and articulately express how the mentoring program will assist with achieving their overall academic and/or professional objectives.
How do I contact the mentors?
Mentor contact details will only be shared once you have been successful in securing a place in the program as a ScholarX mentee.
Can I continue my mentorship relationship at the end of the 3-month program?
At the end of the official mentorship program, if you and your mentor wish to continue your mentoring relationship, we encourage you to do so.
Find a mentor for me
The deadline for the first phase of the program is on 14/04/2019, Application link can be found below For more information and to be added to the waiting list for the next phase of the program, please write to us via<EMAIL_ADDRESS>Mentors
How to be a Mentor?
What are the eligibility requirements?
We look for industry experts and academics who have excelled in their careers
ideally with recognition from industry bodies/international agencies for their work
or have demonstrated exceptional performance in their industry where they represent
a minority group (e.g.: women in STEM industry, entrepreneurs of niche industries).
While we have been very fortunate to host a high calibre of Sri Lankan mentors in
our past program offerings, we are always on the lookout for exceptional mentors
regardless of nationality.
How do I apply to be a mentor?
Submit your CV and expression of interest to<EMAIL_ADDRESS>Do mentors receive any money for participating in ScholarX as a mentor?
No, this is a volunteer run program.
Can I participate in ScholarX as both a mentor and a student?
No. We do not encourage a dual hat approach as this will deteriorate the quality of the offering. Please choose whether participation as a mentor or a mentee achieve your career objectives the best and apply for the most suitable role.
I want to learn more about participating as a mentor in ScholarX. Where can I find more information?
If you have specific queries regarding the role of the mentor , please reach out to us via sustainableedufoundation@gmail.com


So I go to a college where I get drug tested, so naturally I can't smoke weed. So I've been looking into alternatives. Some of them hard illegals that leave your system fast (kind of the irony of drug tests). I have also been looking into legal 'buzzes' not really 'highs'. I found Yerba Mate to be much better than Coffee. And as for legal intoxicants Kava Kava, and Kratom are excellent.
ANYWAY!
I got some baked and sliced betel nuts in the mail today with some edible lime (NOT the fruit, but the mineral).
 Wasnt the most amazing thing I've tasted, oddly bitter and dried up my mouth. But I got used to it fast.
Once the nut was good soft and pulpy I licked the end of my little finger and dipped it into the lime, then tried to place it into the pulp. Kinda worked but I put in too much lime and some spread around my mouth. The lime stung but it wasnt horrid. Once it was all mixed I stuffed it between my jaw and my cheek, like dip. I kept it in for the next 4 hours. I found it gave me a great little buzz. Slightly giddy and talkative. Similar to coffee only smoother. When I found the buzz was going down I would chew on it some more then put it back into the dip position.
4 hours later when I took it out (it had lost all its flavor). I noticed that the lime had eaten away at my gums and cheek. It hurt a bit. I have a feeling it may take sometime to heal. However, shortly after I had spat out my first 'lip' I put in another, only this time after I chewed up the betel nut into a pulp I squeezed the juice out of it in my mouth and then took it out, mixed in some lime while it was *outside* of my mouth. Then I put it back in, I hardly had any lime burn... a little but much better than before.
OVERALL. I found Betel nut to be very nice. They were quite nice, but watch out for the lime burn! It's a bugger! I plan to do it again (seeing as I still have a rather large bag of it) but not anytime soon. Maybe on special occasions but I definitely have to wait for my mouth to heal some first.
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.


5G adoption set to be much faster than 4G
by Steve McCaskill5G adoption set to be much faster than 4G
Ericsson report predicts 2.6bn 5G users and 65 per cent coverage by 2025
(Image credit: Ericsson)
New forecasts suggest there will be 2.6 billion 5G mobile subscriptions around the world by 2025, with next-generation networks covering 65 per cent of the world’s population.
The 2019 edition of the annual Ericsson Mobility Report believes the number of total subscriptions will increase from 8 billion to 8.9 billion over the next six years, by which point more than a quarter will be 5G.
In the more immediate-term, Ericsson says there will be 13 million 5G subscriptions by the end of 2019. This is up from its previous estimate due to the early launch of 5G services in China.
- UK 5G speeds slower than rest of world
- 5G in the UK: everything you need to know
- 5G protests are history repeating itself
5G adoption
“It is encouraging to see that 5G now has broad support from almost all device makers. In 2020, 5G-compatible devices will enter the volume market, which will scale up 5G adoption,” said Fredrik Jejdling, Head of Networks at Ericsson.
“The question is no longer if, but how quickly we can convert use cases into relevant applications for consumers and enterprises. With 4G remaining a strong connectivity enabler in many parts of the world, modernizing networks is also key to this technological change we’re going through.”
The increased availability of 5G, along with the emergence of new data-intensive applications and the rising popularity of online video, will see average data consumption rise from 7.2GB per month per user to 24GB.
It is thought that 5G adoption will be faster than that of 5G but naturally there are some regional variations. By 2025, it is precited that 74 per cent of mobile connections will be 5G, as will 56 per cent of those in North East Asia.
In Western Europe, where operators have made significant investments in 4G infrastructure and the capacity crunch isn’t as severe, the figure is 55 per cent. Meanwhile in Eastern and Central Europe, 4G has only just become the dominant mobile technology. Adoption rates in that region will be around 25 per cent.
- Here are the best mobile phone deals for November 2019


Adobe Analytics
Access Token:
Analytics Company:
Client Key:
Environment:
mc.adobe.io
appservice.omniture.com
appservice2.omniture.com
appservice3.omniture.com
appservice4.omniture.com
appservice5.omniture.com


Galvanize Delivers
Order Delivery
Menu
Order
Burger and Fries
8.99
ADD TO ORDER
Glazed Ribs
14.99
ADD TO ORDER
Ice Cream Sandwich
4.99
ADD TO ORDER
Arrugala Pizza
11.99
ADD TO ORDER
Item
Price
Subtotal
00.00
Tax
00.00
Total
00.00
account_circle
phone
domain
Submit


Object-Oriented Game Programming (Advent of Code, Day 21)
January 11, 2016
The fourth and final post in my Advent of Code series is devoted to two topics that I very much enjoy writing about: games and object-oriented programming. As Advent of Code progressed and the challenges became more complex, there was a definite tipping point (at least in my mind) when taking advantage of Ruby’s classes to program in an object-oriented fashion paid dividends both in terms of quickness in finding a valid solution and in terms of code readability.
My solution to Day 14 was the first problem I solved using Ruby classes (and looking back at my hastily written code, I realize that the methods find_winner
and find_leaders
should probably be converted to class methods). I used classes on the following two days too and also for two of the most engaging problems in the entire sequence: Days 21 and 22. Both of these problems required first simulating and then optimizing a battle of the type that’s usually found in role-playing games.
If we consider the time it took to fill the highly competitive Advent to Code leaderboard as an indicator of a problem’s difficulty, then Day 22 was the hardest day by a considerable margin as it took about 3 hours for the 100 leaderboard spots to be filled (as opposed to 20-30 minutes on an average day). As such, though Day 22 beckons to my typing fingers like a siren’s song (or a bad mixed metaphor), for all of our sakes I have chosen to analyze the similar, but simpler Day 21 problem in this post.
Advent of Code, Day 21 – The Problem
The scenario for this challenge (full details here) is vaguely reminiscent of one of the seminal games of my youth. The randomness of turn order and damage dealt is absent, but the basic concept of a hero with hit points and stat-boosting equipment fighting against an evil boss (who also has hit points and attack/defense stats) is the same. Simulating the rules given for this fight (how attack and defense works) is the programmer’s first battle.
The second battle is to figure out what combination of equipment (weapon, optional armor, and up to two optional rings) allows the hero to win the fight while spending the least amount of gold. In comparison to the complexities inherent in the follow-up challenge on Day 22, this puzzle is rather straightforward as there are no convoluted restrictions present and only a finite number of equipment combinations possible, a number low enough to be processed in mere microseconds. Nonetheless, there is programming to be done and design decisions to be made.
The Basics of Ruby Classes
I still remember the first time I encountered a Ruby class in the wild. I had no idea what its purpose was or what those @
signs were doing in front of the variable names. Now, I can’t imagine programming in Ruby without them, especially when using Ruby for web development.
A lengthy explanation of Ruby classes would be ill-placed here (Chapter 3 of David Black’s excellent The Well-Grounded Rubyist or a Google search can help complete the picture if need be), but basically they are a way to create instances of objects that possess similar characteristics and behavior.
Say we want to represent three different cats in a computer program. (I debated putting an image of three cats sitting together here, but upon further reflection I decided that the Internet already has enough cats.) Each cat has a particular age, breed, and playfulness rating. This is what I mean by “similar characteristics”: even though the ages and breeds of the individual cats might differ, whenever we represent a cat in our program, we will always want it to have these traits. In Ruby, these inherent characteristics are called instance variables and prefaced by the @
sign:
class Cat
def initialize(age, breed, playfulness)
@age = age
@breed = breed
@playfulness = playfulness
end
end
Shared behaviors, for example, meowing, are termed instance methods (they can be called on all instances of a class), and are defined within the class:
class Cat
# ...see above...
def meow
puts "Mee-ooow! I'm #{@age} years old."
end
end
Now it’s simple to batch create cats (well, cats composed of bits and bytes anyway), keep track of their individual traits, and rely on them to exhibit the same behavior:
xerxes = Cat.new(3, "Persian", 5)
java = Cat.new(5, "Balinese", 8)
angara = Cat.new(7, "Siberian", 7)
xerxes.meow
# Output: Mee-ooow! I'm 5 years old.
angara.meow
# Output: Mee-ooow! I'm 7 years old.
Modeling Equipment
Reviewing the Day 21 challenge, one espies an analogous situation to our cats: weapons, armor, and rings each have a name, a cost in gold pieces, a damage value, and an armor value. Due to their common characteristics, it’s possible to combine them into one class, say an Item
class, and be done with it.
However, there is a drawback to such a design choice—it would be harder to do things like restrict a character to exactly one weapon (or, if one were to continue building out the game, locate all the armor in a player’s inventory). For that reason, I have elected to make separate Weapon
, Armor
, and Ring
subclasses that inherit from an Item
superclass:
class Item
attr_reader :name, :cost, :damage, :defense
def initialize(name, cost, damage, defense)
@name = name
@cost = cost
@damage = damage
@defense = defense
end
end
class Weapon < Item
end
class Armor < Item
end
class Ring < Item
end
Now that the classes are in place, it’s easy enough to generate the armory that our hero can choose his equipment from. I’d like to draw particular attention to one design choice I’ve made: since the rules of the challenge declare that the hero need not equip armor or rings, I’ve created dummy values (Bare
, Empty R
, and Empty L
) that signify a lack of equipment. When implemented in this manner, generating possible equipment combinations becomes much more streamlined and makes the absence of armor or rings a fully fledged choice (which it is).
weapons = [
Weapon.new("Dagger", 8, 4, 0),
Weapon.new("Shortsword", 10, 5, 0),
Weapon.new("Warhammer", 25, 6, 0),
Weapon.new("Longsword", 40, 7, 0),
Weapon.new("Greataxe", 74, 8, 0)
]
armor = [
Armor.new("Bare", 0, 0, 0),
Armor.new("Leather", 13, 0, 1),
Armor.new("Chainmail", 31, 0, 2),
Armor.new("Splintmail", 53, 0, 3),
Armor.new("Bandedmail", 75, 0, 4),
Armor.new("Platemail", 102, 0, 5)
]
rings = [
Ring.new("Empty R", 0, 0, 0),
Ring.new("Empty L", 0, 0, 0),
Ring.new("Damage +1", 25, 1, 0),
Ring.new("Damage +2", 50, 2, 0),
Ring.new("Damage +3", 100, 3, 0),
Ring.new("Defense +1", 20, 0, 1),
Ring.new("Defense +2", 40, 0, 2),
Ring.new("Defense +3", 80, 0, 3)
]
Modeling Characters and Battles
With the swords, platemail, and magical rings all ready to go, only characters and the battle sequence remain to be modeled. Here too there are a couple design decisions to be made:
- First, while the hero and the boss share similar stats and attack mechanisms, the means by which the stats are determined are different (as a combination of equipment bonuses for the hero, as innate values for the boss). Possible solutions include incorporating both stat determination methods into a single class or creating two subclasses of
Character
, aHero
and aEnemy
that are initialized differently. - Second, while it seems natural for a one-time
#attack
method to originate from theCharacter
class, the status of the wider, multi-turn battle is less clear. Should it somehow be wrapped into theCharacter
class? Or exist on its own, in which case it could keep track a lot of different values and environmental factors easily?
In both cases, I chose the simpler option, which works perfectly in the short-term, but would probably necessitate refactoring if the RPG simulation were to increase in complexity. Why did I do this? Doesn’t this constitute sloppy design? As I found out while completing my final project at Dev Bootcamp, there is always a tension between achieving very concrete short-term goals and planning for more nebulous long-term needs. When focusing too much on the short term, something called technical debt is accrued, but considering the narrow scope of this project (finding the right answers for Day 21 of Advent of Code), I made a conscious and carefully weighted decision to focus almost exclusively on the short term.
(As it turned out, when completing the Day 22 challenge, I would take the foundation I had from Day 21 and build on it by splitting the Character
class and creating a Battle
class.)
This is the reason why the instantiation method for my Character
class looks the way it does. When creating a “hero,” his equipment is passed in through the options
hash, and then his damage
and defense
stats are generated by private methods based on the stat boosts provided by the equipment. Creating a “boss” is simpler—the precise damage
and defense
stats are included in the options
hash. Both character types have a name and a set number of hit points (HP), so these are required parameters. My code looks like this:
class Character
attr_reader :name, :equipment, :damage, :defense
attr_accessor :hit_points
def initialize(name, hit_points, options = {})
@name = name
@hit_points = hit_points
@equipment = options[:equipment] || []
@damage = options[:damage] || calculate_attack
@defense = options[:defense] || calculate_absorb
end
private
def calculate_attack
equipment.inject(0) { |total, item| total += item.damage }
end
def calculate_absorb
equipment.inject(0) { |total, item| total += item.defense }
end
end
Now that the character stats and hit points are in place, simulating one character attacking another according to the rules given in the challenge is the next step (and should additional modifications such as randomized damage be requested, extremely straightforward to change):
class Character
# ...see above...
def attack(target)
result = self.damage - target.defense
result = 1 if result < 1
target.hit_points -= result
end
Replicating the battle flow is somewhat harder. The two characters exchange blows in turns with the hero always going first. Should the HP of one of the combatants fall to zero, then the battle is immediately over, and the method should return the winning character.
This seemed to me an excellent opportunity to utilize the rather arcane Ruby Array
(and Enumerable
) method #cycle
, which will cycle through an array infinitely, executing a code block at each pass, until a break condition is hit. By putting the hero (who originates the duel) and boss into an array, they can then #attack
each other until one of them falls (the break condition).
My resulting code is rather concise. The appropriate target for the attack is identified by using a ternary operator.
class Character
# ...see above...
def duel_to_the_death(enemy)
hero = self
combatants = [hero, enemy]
combatants.cycle do |character|
character == hero ? target = enemy : target = hero
character.attack(target)
return character if target.hit_points <= 0
end
end
Note that technically speaking there is no need to simulate the battle turn-by-turn—all that’s really needed is a comparison of the number of turns it takes the hero to win with how many turns the boss needs to win (both of which can be determined by simple math), but simulating the turn-based nature of the battle allows us the pleasure of implementing the rarely-used #cycle
method and makes the model much easier to modify should the rules of engagement change.
Advent of Code, Day 21 – A Solution
With the equipment, characters, and battle sequence now modeled as objects and methods, we can finally turn to the “real” programming problem that this challenge posed: what set of equipment allows the hero to win the battle while doing minimal harm to his wallet.
There are 840 possible combinations of equipment when accounting for the absence of armor and/or 1 or 2 rings as options (5 weapons * 6 armor choices * (8 * 7 / 2) combinations of rings). By iterating through each of these 840 combinations, marking which ones result in a victory for the hero, and then comparing the cost of the winning sets, the “thriftiest” set of arms can be determined.
My code uses a triple nested loop to generate the equipment combinations and then sends the hero into battle with each of them. The Enumerable method #min_by
is then called to find the cheapest set, which is analyzed for cost and composition and then printed out. Here is the method in its entirety:
def find_cheapest_win(weapons, armor, rings)
winning_sets = []
weapons.each do |w|
armor.each do |a|
rings.combination(2).to_a.each do |r|
arms = [w, a, r].flatten
hero = Character.new("Knowledge", 100, { equipment: arms })
boss = Character.new("Ignorance", 103, { damage: 9, defense: 2})
if hero.duel_to_the_death(boss) == hero
winning_sets << arms
end
end
end
end
cheapest_set = winning_sets.min_by { |set| set.inject(0) { |total, item| total += item.cost } }
cheapest_cost = cheapest_set.inject(0) { |total, item| total += item.cost }
p [cheapest_cost, cheapest_set.map(&:name)]
end
The boss stats that were provided to me (HP: 103, damage: 9, defense: 2) are hardcoded into the method. When the method is called find_cheapest_win(weapons, armor, rings)
(the parameters refer to the previously constructed arrays of weapons, armor, and defense), the correct result appears in the output:
[121, ["Longsword", "Chainmail", "Empty R", "Damage +2"]]
A close call for the hero as he has only 2 hit points left (and one can very well question the hero’s parsimony as it puts his life in danger and results in a lot of unnecessary wounds), but a win nonetheless!
Part Two and Concluding Thoughts on Object-Oriented Game Programming
Part Two of this challenge was another optimization problem: finding the most expensive set of equipment that results in a loss. A non-DRY approach to this would be to write a #find_costliest_loss
method that closely mimics the above #find_cheapest_win
method, but collects losing sets and uses #max_by
to find the most expensive one. My solution combines the two methods together to (mostly) reduce code repetition.
To wrap up: I’m not sure how clear it is from the preceding code without a counterexample consisting of raw numbers and single-letter variables, but an added benefit of using an object-oriented approach (especially since the Ruby community stresses conventions that make the code easier to read for humans) is that it is relatively effortless to figure out what’s going on at a cursory glance.
With all the named classes, named instance variables, and named local variables within methods, this style of code is less burdensome to maintain and modify. Though I took a few shortcuts (I didn’t bother adding a restriction that a Character
can hold only one Weapon
, subclassing a Hero
and an Enemy
, or creating a separate Battle
class), I believe my codebase represents a solid foundation that’s easily adaptable to future demands. And, in fact, as noted above, I did take advantage of my existing codebase when solving the Day 22 challenge.
Final Reflections on Advent of Code
Advent of Code was really fun to complete. It was also really fun to blog about. The variety of the challenges led me to explore a wide gamut of design concepts and fairly obscure Ruby methods. The complexity of the challenges made them thought-provoking and a good investment of 30 or so minutes daily. Cheers to Eric Wastl for creating it.


provider-signature - The signature library <-> provider functions
#include <openssl/core_dispatch.h>
#include <openssl/core_names.h>
/*
* None of these are actual functions, but are displayed like this for
* the function signatures for functions that are offered as function
* pointers in OSSL_DISPATCH arrays.
*/
/* Context management */
void *OSSL_FUNC_signature_newctx(void *provctx, const char *propq);
void OSSL_FUNC_signature_freectx(void *ctx);
void *OSSL_FUNC_signature_dupctx(void *ctx);
/* Signing */
int OSSL_FUNC_signature_sign_init(void *ctx, void *provkey,
const OSSL_PARAM params[]);
int OSSL_FUNC_signature_sign(void *ctx, unsigned char *sig, size_t *siglen,
size_t sigsize, const unsigned char *tbs, size_t tbslen);
/* Verifying */
int OSSL_FUNC_signature_verify_init(void *ctx, void *provkey,
const OSSL_PARAM params[]);
int OSSL_FUNC_signature_verify(void *ctx, const unsigned char *sig, size_t siglen,
const unsigned char *tbs, size_t tbslen);
/* Verify Recover */
int OSSL_FUNC_signature_verify_recover_init(void *ctx, void *provkey,
const OSSL_PARAM params[]);
int OSSL_FUNC_signature_verify_recover(void *ctx, unsigned char *rout,
size_t *routlen, size_t routsize,
const unsigned char *sig, size_t siglen);
/* Digest Sign */
int OSSL_FUNC_signature_digest_sign_init(void *ctx, const char *mdname,
void *provkey,
const OSSL_PARAM params[]);
int OSSL_FUNC_signature_digest_sign_update(void *ctx, const unsigned char *data,
size_t datalen);
int OSSL_FUNC_signature_digest_sign_final(void *ctx, unsigned char *sig,
size_t *siglen, size_t sigsize);
int OSSL_FUNC_signature_digest_sign(void *ctx,
unsigned char *sig, size_t *siglen,
size_t sigsize, const unsigned char *tbs,
size_t tbslen);
/* Digest Verify */
int OSSL_FUNC_signature_digest_verify_init(void *ctx, const char *mdname,
void *provkey,
const OSSL_PARAM params[]);
int OSSL_FUNC_signature_digest_verify_update(void *ctx,
const unsigned char *data,
size_t datalen);
int OSSL_FUNC_signature_digest_verify_final(void *ctx, const unsigned char *sig,
size_t siglen);
int OSSL_FUNC_signature_digest_verify(void *ctx, const unsigned char *sig,
size_t siglen, const unsigned char *tbs,
size_t tbslen);
/* Signature parameters */
int OSSL_FUNC_signature_get_ctx_params(void *ctx, OSSL_PARAM params[]);
const OSSL_PARAM *OSSL_FUNC_signature_gettable_ctx_params(void *ctx,
void *provctx);
int OSSL_FUNC_signature_set_ctx_params(void *ctx, const OSSL_PARAM params[]);
const OSSL_PARAM *OSSL_FUNC_signature_settable_ctx_params(void *ctx,
void *provctx);
/* MD parameters */
int OSSL_FUNC_signature_get_ctx_md_params(void *ctx, OSSL_PARAM params[]);
const OSSL_PARAM * OSSL_FUNC_signature_gettable_ctx_md_params(void *ctx);
int OSSL_FUNC_signature_set_ctx_md_params(void *ctx, const OSSL_PARAM params[]);
const OSSL_PARAM * OSSL_FUNC_signature_settable_ctx_md_params(void *ctx);
This documentation is primarily aimed at provider authors. See provider(7) for further information.
The signature (OSSL_OP_SIGNATURE) operation enables providers to implement signature algorithms and make them available to applications via the API functions EVP_PKEY_sign(3), EVP_PKEY_verify(3), and EVP_PKEY_verify_recover(3) (as well as other related functions).
All "functions" mentioned here are passed as function pointers between libcrypto and the provider in OSSL_DISPATCH(3) arrays via OSSL_ALGORITHM(3) arrays that are returned by the provider's provider_query_operation() function (see "Provider Functions" in provider-base(7)).
All these "functions" have a corresponding function type definition named OSSL_FUNC_{name}_fn, and a helper function to retrieve the function pointer from an OSSL_DISPATCH(3) element named OSSL_FUNC_{name}. For example, the "function" OSSL_FUNC_signature_newctx() has these:
typedef void *(OSSL_FUNC_signature_newctx_fn)(void *provctx, const char *propq);
static ossl_inline OSSL_FUNC_signature_newctx_fn
OSSL_FUNC_signature_newctx(const OSSL_DISPATCH *opf);
OSSL_DISPATCH(3) arrays are indexed by numbers that are provided as macros in openssl-core_dispatch.h(7), as follows:
OSSL_FUNC_signature_newctx OSSL_FUNC_SIGNATURE_NEWCTX
OSSL_FUNC_signature_freectx OSSL_FUNC_SIGNATURE_FREECTX
OSSL_FUNC_signature_dupctx OSSL_FUNC_SIGNATURE_DUPCTX
OSSL_FUNC_signature_sign_init OSSL_FUNC_SIGNATURE_SIGN_INIT
OSSL_FUNC_signature_sign OSSL_FUNC_SIGNATURE_SIGN
OSSL_FUNC_signature_verify_init OSSL_FUNC_SIGNATURE_VERIFY_INIT
OSSL_FUNC_signature_verify OSSL_FUNC_SIGNATURE_VERIFY
OSSL_FUNC_signature_verify_recover_init OSSL_FUNC_SIGNATURE_VERIFY_RECOVER_INIT
OSSL_FUNC_signature_verify_recover OSSL_FUNC_SIGNATURE_VERIFY_RECOVER
OSSL_FUNC_signature_digest_sign_init OSSL_FUNC_SIGNATURE_DIGEST_SIGN_INIT
OSSL_FUNC_signature_digest_sign_update OSSL_FUNC_SIGNATURE_DIGEST_SIGN_UPDATE
OSSL_FUNC_signature_digest_sign_final OSSL_FUNC_SIGNATURE_DIGEST_SIGN_FINAL
OSSL_FUNC_signature_digest_sign OSSL_FUNC_SIGNATURE_DIGEST_SIGN
OSSL_FUNC_signature_digest_verify_init OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_INIT
OSSL_FUNC_signature_digest_verify_update OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_UPDATE
OSSL_FUNC_signature_digest_verify_final OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_FINAL
OSSL_FUNC_signature_digest_verify OSSL_FUNC_SIGNATURE_DIGEST_VERIFY
OSSL_FUNC_signature_get_ctx_params OSSL_FUNC_SIGNATURE_GET_CTX_PARAMS
OSSL_FUNC_signature_gettable_ctx_params OSSL_FUNC_SIGNATURE_GETTABLE_CTX_PARAMS
OSSL_FUNC_signature_set_ctx_params OSSL_FUNC_SIGNATURE_SET_CTX_PARAMS
OSSL_FUNC_signature_settable_ctx_params OSSL_FUNC_SIGNATURE_SETTABLE_CTX_PARAMS
OSSL_FUNC_signature_get_ctx_md_params OSSL_FUNC_SIGNATURE_GET_CTX_MD_PARAMS
OSSL_FUNC_signature_gettable_ctx_md_params OSSL_FUNC_SIGNATURE_GETTABLE_CTX_MD_PARAMS
OSSL_FUNC_signature_set_ctx_md_params OSSL_FUNC_SIGNATURE_SET_CTX_MD_PARAMS
OSSL_FUNC_signature_settable_ctx_md_params OSSL_FUNC_SIGNATURE_SETTABLE_CTX_MD_PARAMS
A signature algorithm implementation may not implement all of these functions. In order to be a consistent set of functions we must have at least a set of context functions (OSSL_FUNC_signature_newctx and OSSL_FUNC_signature_freectx) as well as a set of "signature" functions, i.e. at least one of:
OSSL_FUNC_signature_set_ctx_params and OSSL_FUNC_signature_settable_ctx_params are optional, but if one of them is present then the other one must also be present. The same applies to OSSL_FUNC_signature_get_ctx_params and OSSL_FUNC_signature_gettable_ctx_params, as well as the "md_params" functions. The OSSL_FUNC_signature_dupctx function is optional.
A signature algorithm must also implement some mechanism for generating, loading or importing keys via the key management (OSSL_OP_KEYMGMT) operation. See provider-keymgmt(7) for further details.
OSSL_FUNC_signature_newctx() should create and return a pointer to a provider side structure for holding context information during a signature operation. A pointer to this context will be passed back in a number of the other signature operation function calls. The parameter provctx is the provider context generated during provider initialisation (see provider(7)). The propq parameter is a property query string that may be (optionally) used by the provider during any "fetches" that it may perform (if it performs any).
OSSL_FUNC_signature_freectx() is passed a pointer to the provider side signature context in the ctx parameter. This function should free any resources associated with that context.
OSSL_FUNC_signature_dupctx() should duplicate the provider side signature context in the ctx parameter and return the duplicate copy.
OSSL_FUNC_signature_sign_init() initialises a context for signing given a provider side signature context in the ctx parameter, and a pointer to a provider key object in the provkey parameter. The params, if not NULL, should be set on the context in a manner similar to using OSSL_FUNC_signature_set_ctx_params(). The key object should have been previously generated, loaded or imported into the provider using the key management (OSSL_OP_KEYMGMT) operation (see provider-keymgmt(7)>.
OSSL_FUNC_signature_sign() performs the actual signing itself. A previously initialised signature context is passed in the ctx parameter. The data to be signed is pointed to be the tbs parameter which is tbslen bytes long. Unless sig is NULL, the signature should be written to the location pointed to by the sig parameter and it should not exceed sigsize bytes in length. The length of the signature should be written to *siglen. If sig is NULL then the maximum length of the signature should be written to *siglen.
OSSL_FUNC_signature_verify_init() initialises a context for verifying a signature given a provider side signature context in the ctx parameter, and a pointer to a provider key object in the provkey parameter. The params, if not NULL, should be set on the context in a manner similar to using OSSL_FUNC_signature_set_ctx_params(). The key object should have been previously generated, loaded or imported into the provider using the key management (OSSL_OP_KEYMGMT) operation (see provider-keymgmt(7)>.
OSSL_FUNC_signature_verify() performs the actual verification itself. A previously initialised signature context is passed in the ctx parameter. The data that the signature covers is pointed to be the tbs parameter which is tbslen bytes long. The signature is pointed to by the sig parameter which is siglen bytes long.
OSSL_FUNC_signature_verify_recover_init() initialises a context for recovering the signed data given a provider side signature context in the ctx parameter, and a pointer to a provider key object in the provkey parameter. The params, if not NULL, should be set on the context in a manner similar to using OSSL_FUNC_signature_set_ctx_params(). The key object should have been previously generated, loaded or imported into the provider using the key management (OSSL_OP_KEYMGMT) operation (see provider-keymgmt(7)>.
OSSL_FUNC_signature_verify_recover() performs the actual verify recover itself. A previously initialised signature context is passed in the ctx parameter. The signature is pointed to by the sig parameter which is siglen bytes long. Unless rout is NULL, the recovered data should be written to the location pointed to by rout which should not exceed routsize bytes in length. The length of the recovered data should be written to *routlen. If rout is NULL then the maximum size of the output buffer is written to the routlen parameter.
OSSL_FUNC_signature_digeset_sign_init() initialises a context for signing given a provider side signature context in the ctx parameter, and a pointer to a provider key object in the provkey parameter. The params, if not NULL, should be set on the context in a manner similar to using OSSL_FUNC_signature_set_ctx_params() and OSSL_FUNC_signature_set_ctx_md_params(). The key object should have been previously generated, loaded or imported into the provider using the key management (OSSL_OP_KEYMGMT) operation (see provider-keymgmt(7)>. The name of the digest to be used will be in the mdname parameter.
OSSL_FUNC_signature_digest_sign_update() provides data to be signed in the data parameter which should be of length datalen. A previously initialised signature context is passed in the ctx parameter. This function may be called multiple times to cumulatively add data to be signed.
OSSL_FUNC_signature_digest_sign_final() finalises a signature operation previously started through OSSL_FUNC_signature_digest_sign_init() and OSSL_FUNC_signature_digest_sign_update() calls. Once finalised no more data will be added through OSSL_FUNC_signature_digest_sign_update(). A previously initialised signature context is passed in the ctx parameter. Unless sig is NULL, the signature should be written to the location pointed to by the sig parameter and it should not exceed sigsize bytes in length. The length of the signature should be written to *siglen. If sig is NULL then the maximum length of the signature should be written to *siglen.
OSSL_FUNC_signature_digest_sign() implements a "one shot" digest sign operation previously started through OSSL_FUNC_signature_digeset_sign_init(). A previously initialised signature context is passed in the ctx parameter. The data to be signed is in tbs which should be tbslen bytes long. Unless sig is NULL, the signature should be written to the location pointed to by the sig parameter and it should not exceed sigsize bytes in length. The length of the signature should be written to *siglen. If sig is NULL then the maximum length of the signature should be written to *siglen.
OSSL_FUNC_signature_digeset_verify_init() initialises a context for verifying given a provider side verification context in the ctx parameter, and a pointer to a provider key object in the provkey parameter. The params, if not NULL, should be set on the context in a manner similar to OSSL_FUNC_signature_set_ctx_params() and OSSL_FUNC_signature_set_ctx_md_params(). The key object should have been previously generated, loaded or imported into the provider using the key management (OSSL_OP_KEYMGMT) operation (see provider-keymgmt(7)>. The name of the digest to be used will be in the mdname parameter.
OSSL_FUNC_signature_digest_verify_update() provides data to be verified in the data parameter which should be of length datalen. A previously initialised verification context is passed in the ctx parameter. This function may be called multiple times to cumulatively add data to be verified.
OSSL_FUNC_signature_digest_verify_final() finalises a verification operation previously started through OSSL_FUNC_signature_digest_verify_init() and OSSL_FUNC_signature_digest_verify_update() calls. Once finalised no more data will be added through OSSL_FUNC_signature_digest_verify_update(). A previously initialised verification context is passed in the ctx parameter. The signature to be verified is in sig which is siglen bytes long.
OSSL_FUNC_signature_digest_verify() implements a "one shot" digest verify operation previously started through OSSL_FUNC_signature_digeset_verify_init(). A previously initialised verification context is passed in the ctx parameter. The data to be verified is in tbs which should be tbslen bytes long. The signature to be verified is in sig which is siglen bytes long.
See OSSL_PARAM(3) for further details on the parameters structure used by the OSSL_FUNC_signature_get_ctx_params() and OSSL_FUNC_signature_set_ctx_params() functions.
OSSL_FUNC_signature_get_ctx_params() gets signature parameters associated with the given provider side signature context ctx and stored them in params. Passing NULL for params should return true.
OSSL_FUNC_signature_set_ctx_params() sets the signature parameters associated with the given provider side signature context ctx to params. Any parameter settings are additional to any that were previously set. Passing NULL for params should return true.
Common parameters currently recognised by built-in signature algorithms are as follows.
Get or sets the name of the digest algorithm used for the input to the signature functions. It is required in order to calculate the "algorithm-id".
Sets the name of the property query associated with the "digest" algorithm. NULL is used if this optional value is not set.
Gets or sets the output size of the digest algorithm used for the input to the signature functions. The length of the "digest-size" parameter should not exceed that of a size_t.
Gets the DER encoded AlgorithmIdentifier that corresponds to the combination of signature algorithm and digest algorithm for the signature operation.
Set this to 1 to use a deterministic ECDSA or DSA digital signature as defined in RFC #6979 (See Section 3.2 "Generation of k"). The default value of 0 uses a random value for the nonce k as defined in FIPS 186-4 Section 6.3 "Secret Number Generation". Before using deterministic digital signature please read RFC #6979 Section 4 "Security Considerations".
Sets a flag to modify the sign operation to return an error if the initial calculated signature is invalid. In the normal mode of operation - new random values are chosen until the signature operation succeeds. By default it retries until a signature is calculated. Setting the value to 0 causes the sign operation to retry, otherwise the sign operation is only tried once and returns whether or not it was successful. Known answer tests can be performed if the random generator is overridden to supply known values that either pass or fail.
OSSL_FUNC_signature_gettable_ctx_params() and OSSL_FUNC_signature_settable_ctx_params() get a constant OSSL_PARAM(3) array that describes the gettable and settable parameters, i.e. parameters that can be used with OSSL_FUNC_signature_get_ctx_params() and OSSL_FUNC_signature_set_ctx_params() respectively.
See OSSL_PARAM(3) for further details on the parameters structure used by the OSSL_FUNC_signature_get_md_ctx_params() and OSSL_FUNC_signature_set_md_ctx_params() functions.
OSSL_FUNC_signature_get_md_ctx_params() gets digest parameters associated with the given provider side digest signature context ctx and stores them in params. Passing NULL for params should return true.
OSSL_FUNC_signature_set_ms_ctx_params() sets the digest parameters associated with the given provider side digest signature context ctx to params. Any parameter settings are additional to any that were previously set. Passing NULL for params should return true.
Parameters currently recognised by built-in signature algorithms are the same as those for built-in digest algorithms. See "Digest Parameters" in provider-digest(7) for further information.
OSSL_FUNC_signature_gettable_md_ctx_params() and OSSL_FUNC_signature_settable_md_ctx_params() get a constant OSSL_PARAM(3) array that describes the gettable and settable digest parameters, i.e. parameters that can be used with OSSL_FUNC_signature_get_md_ctx_params() and OSSL_FUNC_signature_set_md_ctx_params() respectively.
OSSL_FUNC_signature_newctx() and OSSL_FUNC_signature_dupctx() should return the newly created provider side signature, or NULL on failure.
OSSL_FUNC_signature_gettable_ctx_params(), OSSL_FUNC_signature_settable_ctx_params(), OSSL_FUNC_signature_gettable_md_ctx_params() and OSSL_FUNC_signature_settable_md_ctx_params(), return the gettable or settable parameters in a constant OSSL_PARAM(3) array.
All other functions should return 1 for success or 0 on error.
The provider SIGNATURE interface was introduced in OpenSSL 3.0.
Copyright 2019-2022 The OpenSSL Project Authors. All Rights Reserved.
Licensed under the Apache License 2.0 (the "License"). You may not use this file except in compliance with the License. You can obtain a copy in the file LICENSE in the source distribution or at https://www.openssl.org/source/license.html.


The BBC micro:bit contains a magnetometer or electronic compass. This demo shows how you can obtain directional data over a Bluetooth Low Energy connection and use it in an application.
Magnetometer data may be obtained from the Bluetooth Magnetometer Service's Magnetometer Data characteristic as raw X, Y, Z values or as a 'bearing' in degrees from the Magnetometer Bearing characteristic. Each time the magnetometer is polled, new values become available. All Values from either characteristic may be transmitted to this application as Bluetooth Notifications. To make this happen, the code must first subscribe to notifications relating to the Magnetometer Data characteristic and/or Magnetometer Bearing characteristic by setting the associated Client Characteristic Configuration Descriptor (CCCD) to 0x0100. Once this has been done, notification messages will be delivered to the BleAdapterService object and from there passed as a Message to the MagnetometerActivity object for processing.
You can control how often the magnetometer is polled via the Settings screen. When you change the polling frequency, the new value is sent to the micro:bit by writing it to the Magnetometer Service\'s Magnetometer Period characteristic.
Raw magnetometer data from the micro:bit can be a bit jerky and so a low pass filter function is used to smooth the data. Have a look at the lowPass function in the Utility class to see how this works.
The first time you use the MicroBitCompass class it should trigger a calibration procedure which invlolves drawing a circle with the micro:bit. Just follow the instructions on the display of the micro:bit.


This box has no positioning, so it is placed at coordinates 0,0.
This box has absolute positioning.
This box also has absolute positioning.


Cameras, motion detection, and (interesting) object detection (part two)
Well, it didn’t take long for me to tweak my setup, so before we get to the template, and other things, I’ll explain what I’ve changed.
Same, but different
I’ve been using one webhook to trigger everything, and blindly assume that the interesting activity ends a minute later. This is done with the Call a Web Hook option in MotionEye. That simply adds to the on_event_start
option. There’s also an on_event_end
command, that can be used for this, with a little work. I ended up writing a really simple shell script to make the required call, identifying whether this is the start or end of an event, and which camera it’s on. I’m not using the camera information yet, but I’ll add that eventually.
Now I’m using the same webhook for the start and end, I’m firing an event from that webhook, with the information, that’s consumed by the event start and event stop automations. This simply makes it easier to ensure that when I’m streaming the video it doesn’t cut off until all the activity has finished.
Streaming logic
When streaming is enabled, I want it to “follow us”. I’ve built some simple logic that uses the fact that I already track which rooms are occupied. This sets an input select to match the target media player.
{%- if is_state('input_boolean.office_occupied','on') -%}
media_player.office_smart_display
{%- elif is_state('input_boolean.living_room_occupied','on') -%}
media_player.living_room_display
{%- elif is_state('input_boolean.master_bedroom_occupied','on') -%}
media_player.master_bedroom_display
{%- else -%}
media_player.family_room_display
{%- endif -%}
The logic is simple, the rooms are listed in the priority order, and if nothing else is occupied it “falls through” to the family room.
I set an input select so that when the stream is stopped, it stops the right media player. This avoids the situation where a room becomes unoccupied between the camera stream starting and stopping.
Doods
The configuration for Doods itself is as follows:
- name: default
type: tensorflow
modelFile: /share/doods/models/faster_rcnn_inception_v2_coco_2018_01_28.pb
labelFile: /share/doods/models/coco_labels1.txt
numThreads: 4
numConcurrent: 2
hwAccel: false
timeout: 30s
Given that it’s typically taking about 0.8 seconds, that 30 second timeout is quite excessive.
Tensorflow
As you probably noticed I’m using the faster_rcnn_inception_v2_coco_2018_01_28
models, on the full Tensorflow. I found the lite models horribly inaccurate, where it was detecting rocks as people, yet not detecting the (larger) people in the same image. On my hardware this still takes under a second, but the accuracy is good.
Doods Integration
The integration’s configuration is here, I’ve had the confidence set down at 60%, but I’ve turned it up to 70%, and I suspect I’ll move that to 75%. As my notifications include details on the detections I’ve got a log I’m using for tuning.
I’ve excluded the top 50% of the image, and the right 40% since all the things I’m interested in will be in that area. This basically matches the detection area for Motion. I’ve said that I’m interested in matches that go outside the area, because sometimes the objects that cause detection, which I’m still interested in, go outside that area.
The objects I’ve said I’m interested in are person, car, truck, motorcycle, bicycle, cat, dog, bird. I’m not really interested in the last three, but they cause enough motion detections I’m curious to see how Doods does at identifying them. So far, it hasn’t identified any
Finding the relevant things
So, there’s that 60 line template-of-doom. What does it do exactly?
First off, we extract the count of things we’re interested in:
{%- set totalPeople = state_attr('image_processing.doods_front_camera_snapshot','summary').person|default(0) -%}
{%- set totalCars = state_attr('image_processing.doods_front_camera_snapshot','summary').car|default(0) -%}
{%- set totalTrucks = state_attr('image_processing.doods_front_camera_snapshot','summary').truck|default(0) -%}
{%- set totalMotorcycles = state_attr('image_processing.doods_front_camera_snapshot','summary').motorcycle|default(0) -%}
{%- set totalBicycles = state_attr('image_processing.doods_front_camera_snapshot','summary').bicycle|default(0) -%}
Then we set some default values (zero):
{%- set parkedCars = 0 -%}
{%- set otherCars = 0 -%}
{%- set parkedTrucks = 0 -%}
{%- set otherTrucks = 0 -%}
{%- set relevantPeople = 0 -%}
{%- set otherPeople = 0 -%}
Next we define a macro to see if the vehicle detected is in one of the parking spaces:
{%- macro isParked(box) -%}
{{- True if (
((0.715 < box[0] < 0.754) and (0.340 < box[1] < 0.482) and (0.820 < box[2] < 0.852) and (0.500 < box[3] < 0.580))
or
((0.740 < box[0] < 0.766) and (0.318 < box[1] < 0.400) and (0.830 < box[2] < 0.854) and (0.380 < box[3] < 0.550))
) else X -}}
{%- endmacro -%}
I could probably simplify this to check the two spaces as a whole. All this does is check to see if the corners of the detected object are inside what’s normal for detections in that space.
Next up we check to see if the cars (or trucks, since sometimes the larger car is picked up as a truck) we see are in a parking space (boring) or not (interesting):
{%- if totalCars > 0 -%}
{%- macro getParkedCars() -%}
{%- for state in state_attr('image_processing.doods_front_camera_snapshot','matches').car -%}{{- "X" if isParked(state.box) -}}{%- endfor -%}
{%- endmacro -%}
{%- set parkedCars = getParkedCars()|length -%}
{%- set otherCars = state_attr('image_processing.doods_front_camera_snapshot','summary').car - parkedCars -%}
{%- endif -%}
We do the same for the trucks then total up the vehicles into parked and other:
{%- set parkedVehicles = parkedCars+parkedTrucks -%}
{%- set otherVehicles = otherCars+otherTrucks -%}
Now it’s time to look at the people. Here were mainly interested in people on the path or in the garden, rather than those on the access road. Yes, this means I’ll miss out on notifications of people walking to the parking spaces, but that’s not something I’m concerned about.
{%- if totalPeople > 0 -%}
{%- macro personOnPath(box) -%}
{{- True if (
( 0.885 < box[2] )
) else X -}}
{%- endmacro -%}
{%- macro getPeopleOnPath() -%}
{%- for state in state_attr('image_processing.doods_front_camera_snapshot','matches').person -%}{{- "X" if personOnPath(state.box) -}}{%- endfor -%}
{%- endmacro -%}
{%- set relevantPeople = getPeopleOnPath()|length -%}
{%- set otherPeople = state_attr('image_processing.doods_front_camera_snapshot','summary').person - relevantPeople -%}
{%- endif -%}
Finally we total up the things that are interesting, and report that.
{#- total up the things into different categories -#}
{%- set importantThings = otherCars + otherTrucks + totalMotorcycles + totalBicycles + relevantPeople -%}
{{ importantThings }}
In short, I’m interested in vehicles not in the parking spaces, any bikes, and people in the garden/path. We use this information in the notification script to decide which channel it goes to, and whether the camera will be streamed to a smart display.
Notification time
Notification logic is “simple”:
- Doods found nothing then the notification goes to a muted Discord channel
- Doods found something, but nothing interesting, the notification goes to that same channel
- Doods found something interesting, the notification goes to a different channel
All notifications include the confidence and bounding box of what was found, so that I can tune the template logic and Doods configuration. The muted channel gives me a history I can review too, in case I filtered out interesting things.
What’s next?
I’ve noticed that when I cast to my Home Hub Max the image is rotated 90 degrees. I need to investigate and see if that’s a problem at the HA end (seems pretty unlikely) or at the Google end (seems more likely).
I’m thinking of getting one of the Google Coral sticks. There’s some interesting examples out there using the stick to do near real time object detection, separate from motion detection. That has interesting possibilities for making this even smarter, rather than just checking for interesting objects at two fixed points, continually check for interesting objects during a motion detection.


Gecode::Gist::SpaceNode Class Reference
A node of a search tree of Gecode spaces. More...
#include <spacenode.hh>
Public Member Functions | |
| SpaceNode (int p) | |
| Construct node with parent p. | |
| SpaceNode (Space *root) | |
| Construct root node from Space root and branch-and-bound object better. | |
| Space * | getSpace (NodeAllocator &na, BestNode *curBest, int c_d, int a_d) |
| Return working space. Receiver must delete the space. | |
| const Space * | getWorkingSpace (void) const |
| Return working space (if present). | |
| void | purge (const NodeAllocator &na) |
| Clear working space and copy (if present and this is not the root). | |
| void | dispose (void) |
| Free allocated memory. | |
| bool | isCurrentBest (BestNode *curBest) |
| Return whether this node is the currently best solution. | |
| int | getNumberOfChildNodes (NodeAllocator &na, BestNode *curBest, Statistics &stats, int c_d, int a_d) |
| Compute and return the number of children. | |
| NodeStatus | getStatus (void) const |
| Return current status of the node. | |
| bool | isOpen (void) |
| Return whether this node still has open children. | |
| bool | hasFailedChildren (void) |
| Return whether the subtree of this node has any failed children. | |
| bool | hasSolvedChildren (void) |
| Return whether the subtree of this node has any solved children. | |
| bool | hasOpenChildren (void) |
| Return whether the subtree of this node has any open children. | |
| int | getNoOfOpenChildren (const NodeAllocator &na) |
| Return number of open children. | |
| void | setNoOfOpenChildren (int n) |
| Set number of open children to n. | |
| bool | hasCopy (void) |
| Return whether the node has a copy. | |
| bool | hasWorkingSpace (void) |
| Return whether the node has a working space. | |
| int | getAlternative (const NodeAllocator &na) const |
| Return alternative number of this node. | |
| const Choice * | getChoice (void) |
| Return choice of this node. | |
Protected Types | |
| enum | SpaceNodeFlags { HASOPENCHILDREN = FIRSTBIT, HASFAILEDCHILDREN, HASSOLVEDCHILDREN } |
Flags for SpaceNodes. More... | |
Protected Member Functions | |
| void | setDistance (unsigned int d) |
| Set distance from copy. | |
| unsigned int | getDistance (void) const |
| Return distance from copy. | |
| void | setFlag (int flag, bool value) |
| Set status flag. | |
| bool | getFlag (int flag) const |
| Return status flag. | |
| void | setStatus (NodeStatus s) |
| Set status to s. | |
| void | acquireSpace (NodeAllocator &na, BestNode *curBest, int c_d, int a_d) |
| Acquire working space, either from parent or by recomputation. | |
Protected Attributes | |
| Space * | copy |
| A copy used for recomputation, or NULL. | |
| const Choice * | choice |
| unsigned int | nstatus |
| Status of the node. | |
Static Protected Attributes | |
| static const int | LASTBIT = HASSOLVEDCHILDREN |
| Last bit used for SpaceNode flags. |
Detailed Description
A node of a search tree of Gecode spaces.
Definition at line 93 of file spacenode.hh.
Member Enumeration Documentation
enum Gecode::Gist::SpaceNode::SpaceNodeFlags [protected] |
Flags for SpaceNodes.
Definition at line 125 of file spacenode.hh.
Constructor & Destructor Documentation
| Gecode::Gist::SpaceNode::SpaceNode | ( | int | p | ) | [inline] |
Construct node with parent p.
Definition at line 93 of file spacenode.hpp.
| Gecode::Gist::SpaceNode::SpaceNode | ( | Space * | root | ) |
Construct root node from Space root and branch-and-bound object better.
Definition at line 280 of file spacenode.cpp.
Member Function Documentation
| void Gecode::Gist::SpaceNode::setDistance | ( | unsigned int | d | ) | [inline, protected] |
Set distance from copy.
Definition at line 80 of file spacenode.hpp.
| unsigned int Gecode::Gist::SpaceNode::getDistance | ( | void | ) | const [inline, protected] |
Return distance from copy.
Definition at line 88 of file spacenode.hpp.
| void Gecode::Gist::SpaceNode::setFlag | ( | int | flag, | |
| bool | value | |||
| ) | [inline, protected] |
Set status flag.
Definition at line 41 of file spacenode.hpp.
| bool Gecode::Gist::SpaceNode::getFlag | ( | int | flag | ) | const [inline, protected] |
Return status flag.
Definition at line 49 of file spacenode.hpp.
| void Gecode::Gist::SpaceNode::setStatus | ( | NodeStatus | s | ) | [inline, protected] |
Set status to s.
Definition at line 69 of file spacenode.hpp.
| void Gecode::Gist::SpaceNode::acquireSpace | ( | NodeAllocator & | na, | |
| BestNode * | curBest, | |||
| int | c_d, | |||
| int | a_d | |||
| ) | [protected] |
Acquire working space, either from parent or by recomputation.
Definition at line 160 of file spacenode.cpp.
| Space * Gecode::Gist::SpaceNode::getSpace | ( | NodeAllocator & | na, | |
| BestNode * | curBest, | |||
| int | c_d, | |||
| int | a_d | |||
| ) | [inline] |
Return working space. Receiver must delete the space.
Definition at line 102 of file spacenode.hpp.
| const Space * Gecode::Gist::SpaceNode::getWorkingSpace | ( | void | ) | const [inline] |
Return working space (if present).
Definition at line 116 of file spacenode.hpp.
| void Gecode::Gist::SpaceNode::purge | ( | const NodeAllocator & | na | ) | [inline] |
Clear working space and copy (if present and this is not the root).
Definition at line 124 of file spacenode.hpp.
| void Gecode::Gist::SpaceNode::dispose | ( | void | ) |
Free allocated memory.
Reimplemented in Gecode::Gist::VisualNode.
Definition at line 295 of file spacenode.cpp.
| bool Gecode::Gist::SpaceNode::isCurrentBest | ( | BestNode * | curBest | ) | [inline] |
Return whether this node is the currently best solution.
Definition at line 137 of file spacenode.hpp.
| int Gecode::Gist::SpaceNode::getNumberOfChildNodes | ( | NodeAllocator & | na, | |
| BestNode * | curBest, | |||
| Statistics & | stats, | |||
| int | c_d, | |||
| int | a_d | |||
| ) |
Compute and return the number of children.
On a node whose status is already determined, this function just returns the number of children. On an undetermined node, it first acquires a Space (possibly through recomputation), and then asks for its status. If the space is solved or failed, the node's status will be set accordingly, and 0 will be returned. Otherwise, the status is SS_BRANCH, and as many new children will be created as the branch has alternatives, and the number returned.
Definition at line 302 of file spacenode.cpp.
| NodeStatus Gecode::Gist::SpaceNode::getStatus | ( | void | ) | const [inline] |
Return current status of the node.
Definition at line 75 of file spacenode.hpp.
| bool Gecode::Gist::SpaceNode::isOpen | ( | void | ) | [inline] |
Return whether this node still has open children.
Definition at line 142 of file spacenode.hpp.
| bool Gecode::Gist::SpaceNode::hasFailedChildren | ( | void | ) | [inline] |
Return whether the subtree of this node has any failed children.
Definition at line 148 of file spacenode.hpp.
| bool Gecode::Gist::SpaceNode::hasSolvedChildren | ( | void | ) | [inline] |
Return whether the subtree of this node has any solved children.
Definition at line 153 of file spacenode.hpp.
| bool Gecode::Gist::SpaceNode::hasOpenChildren | ( | void | ) | [inline] |
Return whether the subtree of this node has any open children.
Definition at line 158 of file spacenode.hpp.
| int Gecode::Gist::SpaceNode::getNoOfOpenChildren | ( | const NodeAllocator & | na | ) |
Return number of open children.
Definition at line 373 of file spacenode.cpp.
| void Gecode::Gist::SpaceNode::setNoOfOpenChildren | ( | int | n | ) |
Set number of open children to n.
| bool Gecode::Gist::SpaceNode::hasCopy | ( | void | ) | [inline] |
Return whether the node has a copy.
Definition at line 163 of file spacenode.hpp.
| bool Gecode::Gist::SpaceNode::hasWorkingSpace | ( | void | ) | [inline] |
Return whether the node has a working space.
Definition at line 168 of file spacenode.hpp.
| int Gecode::Gist::SpaceNode::getAlternative | ( | const NodeAllocator & | na | ) | const [inline] |
Return alternative number of this node.
Definition at line 173 of file spacenode.hpp.
| const Choice * Gecode::Gist::SpaceNode::getChoice | ( | void | ) | [inline] |
Return choice of this node.
Definition at line 185 of file spacenode.hpp.
Member Data Documentation
Space* Gecode::Gist::SpaceNode::copy [protected] |
A copy used for recomputation, or NULL.
If the copy is marked, it is a working copy, i.e., it does not have to be kept for recomputation.
Definition at line 100 of file spacenode.hh.
const Choice* Gecode::Gist::SpaceNode::choice [protected] |
Definition at line 102 of file spacenode.hh.
unsigned int Gecode::Gist::SpaceNode::nstatus [protected] |
Status of the node.
If the node has a working copy, the first 20 bits encode the distance to the closest copy. The next 5 bits encode the NodeStatus, and the remaining bits are used by the VisualNode class for further flags.
Definition at line 110 of file spacenode.hh.
const int Gecode::Gist::SpaceNode::LASTBIT = HASSOLVEDCHILDREN [static, protected] |
Last bit used for SpaceNode flags.
Definition at line 131 of file spacenode.hh.
The documentation for this class was generated from the following files:
- gecode/gist/spacenode.hh (Revision: 11343)
- gecode/gist/spacenode.cpp (Revision: 13613)
- gecode/gist/spacenode.hpp (Revision: 11347)


{% extends "base.html" %} {% block title %}User Registration Success{% endblock title %} {% block sidenav %}
You have successfully registered.
Click here to log in.


The NanoGong applet shown below does not have three of the usual components on its interface. They are the save button, speed buttons and the audio level indicator. Hiding of any these components (also the record button) can be achieved by setting the corresponding applet parameters. The color of the applet is changed using the color applet parameter. The time display is enabled and will be shown if you hold your mouse over the timeline.
More information about NanoGong can be obtained from http://gong.ust.hk/nanogong/.


10 Things About... 10 Things I Hate About You
By Ross Anthony
1) Shakespeare can be overbearing ... so many words so fast. This rewrite of William Shakespeare's "Taming of the Shrew" is much more palatable stripped of the Old English encryptions. 2) One viewer exclaimed, "Better than 'Shakespeare in love!'"  Over-protective dad (thinking it a safe bet) won't allow the younger to date until the older does. However, some young men interested in dating the younger pay off an equally anti-social senior male to date the elder. 4) Slow beginning, then captivating. 5) Often very funny with a few endearing moments (one even jerked a tear from me). 6) Great acting by leads. 7) Well paced. 8) Daryl Mitchell is hilarious as the literature teacher -- he raps to Shakespeare. 9) Good music. 10) Stay for ending credits.
Starring Heath Ledger and Julia Stiles, Joseph-Gordon Levitt and Larisa Oleynik. Directed by Gil Junger. Written by Karen McCullah Lutz and Kirsten Smith. Produced by Andrew Lazar at Touchstone/Buena Vista. Rated PG-13.
Grade (Adults)................................... B+ Grade (Teens)................................... A-
-- Copyright © 1999 Ross Anthony, currently based in Los Angeles, has scripted and shot documentaries, music videos, and shorts in 35 countries across North America, Europe, Africa and Asia. For more reviews visit: http://RossAnthony.com
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


These resources are compiled as a guide for adventurous teachers that are setting out to reach for the stars and integrated Javascript coding into their curriculum. Most of the material herein is not provided as a turnkey solution. This guide is intended as just that, a collection of good advice to help you find your way. Word of advise befriend a programmer.
Please feel free to contribute & share this manual, there is so much work to be done. This document is just a repository on Github, you can find it here.
Add us on facebook and join the movement.
Stay tuned new, information is added weekly.


CyberSearch is an open source metasearch engine with a special focus on
privacy and efficiency. All it really does is proxies results from Bing and Wikipedia to you with a customizable
user interface.
How CyberSearch Works
When you search on our site, we take results from Bing and Wikipedia,
organize them, and
display them directly to you without logging any identifiable information about you.
How We Make Money
CyberSearch doesn't make any money.
About Our Company
CyberSearch is part of CyberSafe Labs, Inc. and we are just a small
team working to improve softwares.


My name is Noah Chae. I live in New Jersey and am currently being homeschooled. My name is Noah Chae. I live in New Jersey and am currently being homeschooled. My name is Noah Chae. I live in New Jersey and am currently being homeschooled. My name is Noah Chae. I live in New Jersey and am currently being homeschooled. My name is Noah Chae. I live in New Jersey and am currently being homeschooled. My name is Noah Chae. I live in New Jersey and am currently being homeschooled. My name is Noah Chae.


WebAudioXML - FM Synth
ON
MODULATOR
GAIN
PITCH
CARRIER
GAIN
ENV
A
D
S
R
https://github.com/hanslindetorp/WebAudioXML


White to play 43
pips White=119 Black=90
(CorrectAnswer= 0/0, ErrorScore= 0)
1. 6/3 6/2 eq: -0.675 23.47% (G: 4.08% B:0.08%) 76.53% (G:24.74% B:1.82%) 2. 8/4 6/3 eq: -0.694 (-0.020) 21.43% (G: 3.44% B:0.06%) 78.57% (G:21.45% B:1.64%) 3. 8/5 6/2 eq: -0.705 (-0.030) 20.97% (G: 3.21% B:0.07%) 79.03% (G:20.76% B:1.61%) 4. 8/4 5/2 eq: -0.755 (-0.080) 19.04% (G: 2.33% B:0.06%) 80.96% (G:21.47% B:1.21%) 5. 8/1 eq: -0.799 (-0.124) 17.35% (G: 1.74% B:0.05%) 82.65% (G:21.18% B:1.32%)