Custom database queries can be executed from the SQL Query view in Postico. You can get to the SQL Query View by clicking on "SQL Query" in the sidebar. There's also a keyboard shortcut (⇧⌘T) to navigate to the query view.
The query view highlights the current statement in light grey. Use the command "Execute Query" in the "Connection" menu or press ⌘↩ to execute the current statement (or the current selection, if any). The corresponding results are displayed below the text view.
You can execute multiple statements at once by selecting them. They will be executed in an implicit transaction, so if one of the statements fails, all changes to the database will be rolled back.
When you execute multiple statements, Postico will display the first result. You can switch between results using a popup menu button at the bottom left.
Use the command "Execute All Queries" in the "Connection" menu or ⌥⌘↩ to execute all statements at once.
To clear the result area, use the command "Clear Results" in the "Connection" menu or press ⌘K.
There are two autocomplete modes available in the SQL query view.
In the autocompletion window, use the arrow keys to select a completion, then hit the return key to confirm.
Multiple matches of the same suggestion will be grouped by type, use the left and right arrow keys to expand and collapse grouped suggestions.
Multiple selected lines can be indented at once.
Use the command "Shift Right" in the "Edit" menu or press ⇥ or ⌘] to shift the selected line(s) to the right (increase indentation).
Use the command "Shift Left" in the "Edit" menu or press ⇧⇥ or ⌘[ to shift the selected line(s) to the left (decrease indentation).
If you have Dash installed, you can use the command "Look Up In Dash" in the context menu or press Ctrl-H to look up the current word (or selection) in Dash.


DARQ is capable of making a new era of technology in all fields of science. DARQ gives a new revolution to computing by making processing faster, optimizing internet speed, and data encryption. DARQ is a combination of the four key technologies that will lead the way of innovation. They are Distributed Ledger Technology, Artificial Intelligence, Extended Reality, And Quantum Computing. Collectively they will push each other forward and open unimagined and new pathways into the future.
Highlight
Separated they live in Bookmarksgrove right at the coast of the Semantics, a large language ocean. A small river named Duden flows by their place and supplies it with the necessary regelialia
“She packed her seven versalia, put her initial into the belt and made herself on the way. When she reached the first hills of the Italic Mountains, she had a last view back on the skyline of her hometown Bookmarksgrove ” — Jean Smith
Distributed Ledger Technology (DLT) refers to the technological infrastructure and protocols that allows simultaneous access, validation, and record updating in an immutable manner across a network that's spread across multiple entities or locations. Most relevant examples include cryptocurrency and blockchain. The source of truth/original data is a single point and with that people can easily transact money and convey important details without any fear of data breach or hacking. The data is not only conveyed safely but also is verified once it reaches its destination, thus providing double layer protection of data.
Artificial intelligence (AI) refers to the simulation of human intelligence in machines that are programmed to think like humans and mimic their actions. Businesses and companies are automating tasks and thus reducing the human effort in machinery work, rather employees are being engaged in more productive work where human interaction is a must and that involve creativity and empathy among others. Artificial intelligence is already ubiquitous in our digital lives.
Extended reality (XR) a term referring to all real-and-virtual combined environments and human-machine interactions generated by computer technology and wearables, where the 'X' represents a variable for any current or future spatial computing technologies. It is a combination of augmented reality, virtual reality, and mixed reality. In simple words, nearly all forms of technologically-supplemented reality fall under the XR umbrella. With the advancement of technology, extended reality can be used to test almost everything, which is not possible in the real world. However, for XR to reach its full capacity we must overcome the current challenge of network connectivity, application development and processing power.
Quantum computing is an area of study focused on the development of computer- based technologies centered around the principles of quantum theory. Quantum computing is the exploitation of collective properties of quantum states, such as superposition and entanglement, to perform computation. The devices that perform quantum computations are known as quantum computers. Quantum computing will likely power many new advancements in chemistry and materials science, resulting in new drugs and product advancement. Other uses include traffic optimization, supply chain, logistics, and cybersecurity. It is so powerful and dynamic that it will be able to solve all those problems which were earlier unsolvable.
While each of the individual emerging technologies that make up DARQ are at a different point on the adoption curve, it’s clear that the first wave of companies using DARQ technologies to drive differentiation is already here. Once the collective power of DARQ begins to manifest itself, it might be too late for adopters who lag behind to catch up. DARQ technologies are so powerful and influential. DARQ technology has much potential to change the way we think and find solutions to our problem and can revolutionize the decision-making process. So undoubtedly, we can say the future is DARQ but bright.


fun train(cases: Cases): Unit
Overrides Model.train
Trains the model on a set of input-output cases.
The best solution found will be kept and defines the model found for the program being searched for.
cases - A set of input-output cases.
cases


#include <bsController.h>
Classes | |
| struct | EmitterInstance |
| struct | Event |
| struct | MemberController |
Public Member Functions | |
| Controller (ScriptMachine *machine) | |
| Constructor. | |
| void | onRelease () |
| Callback for when the Controller is no longer needed. | |
| void | setDefinition (ControllerDefinition *def, bstype x, bstype y, bstype angle) |
| Set a Controller instance to use the specified ControllerDefinition. | |
| void | enable (bool enable) |
| Enables or disables the Controller, and its Emitters. | |
| bool | isEnabled () const |
| Tests whether the Controller is currently enabled or disabled. | |
| void | setX (bstype x) |
| Set the X position of this Controller. | |
| void | setY (bstype y) |
| Set the Y position of this Controller. | |
| void | setPosition (bstype x, bstype y) |
| Set the position of this Controller. | |
| void | setAngle (bstype facing, bstype orbit) |
| Set the angle of this Controller, in degrees. | |
| void | setMember (int member, bstype value) |
| Set the specified member of the Controller. | |
| void | setUserObject (void *userObject) |
| Set the user-supplied object for this Controller. | |
| void * | getUserObject () const |
| Get the user-supplied object for this Controller. | |
| void | setState (int state) |
| Set the Controller state. | |
| void | setEmitterMember (int emitter, int member, bstype value) |
| Set the specified member of an Emitter controlled by this Controller. | |
| void | setEmitterMember (int emitter, int member, bstype value, float time) |
| Interpolate the specified member of an Emitter controlled by this Controller. | |
| bstype | getEmitterMember (int emitter, int member) const |
| Get the value of an Emitter member variable. | |
| void | setEmitterMemberState (int emitter, int state) |
| Set an Emitter's state. | |
| int | raiseEvent (const String &evt, const bstype *args) |
| Triggers an event in the Controller. | |
| bool | _raiseEvent (int index, const bstype *args) |
| Triggers an event in the Controller. | |
| void | addBlock (bstype block) |
| Adds a block to the Controller. | |
| void | signal (bstype block) |
| Removes a block from the Controller. | |
| void | resume () |
| Resumes the Controller from a waiting state. | |
| void | enableEmitter (int index, bool enable) |
| Enables or disables the Emitter. | |
| void | update (float frameTime) |
| Update the Controller. |
Controllers are script objects which can control Emitters in a similar way that those emit objects. They have a concept of states, and can also be driven explicitly by the user via events. They can modify Emitter member variables, as well as enabling or disabling the Emitters themselves.
| BS_NMSP::Controller::Controller | ( | ScriptMachine * | machine | ) | [explicit] |
Constructor.
| machine | pointer to an active ScriptMachine. |
| bool BS_NMSP::Controller::_raiseEvent | ( | int | index, | |
| const bstype * | args | |||
| ) |
Triggers an event in the Controller.
This function is for internal use.
| index | index of the event to raise. | |
| args | array of values to pass as arguments. |
| void BS_NMSP::Controller::addBlock | ( | bstype | block | ) |
Adds a block to the Controller.
Blocks are used to suspend a Controller state, and only resume when the blocks have been signalled to it, via an event, or code. This way states can wait upon multiple events before resuming. In the case that the block already exists, it is not added.
| block | the value to act as a block. |
| void BS_NMSP::Controller::enable | ( | bool | enable | ) |
Enables or disables the Controller, and its Emitters.
| enable | enables if true, disables if false. |
| void BS_NMSP::Controller::enableEmitter | ( | int | index, | |
| bool | enable | |||
| ) |
| bstype BS_NMSP::Controller::getEmitterMember | ( | int | emitter, | |
| int | member | |||
| ) | const |
Get the value of an Emitter member variable.
This is used for built-in member variables as well as user-defined ones. Hence, the first user variable is at index NUM_SPECIAL_MEMBERS (defined in bsCore.h).
| emitter | index of the emitter instance. | |
| member | index of the user member variable. |
| void* BS_NMSP::Controller::getUserObject | ( | ) | const |
Get the user-supplied object for this Controller.
The user object can be used to pass information to the emit function. This is useful because Controller are updated by the bulletscript machine in one go, and the user is otherwise unable to intercept the update to set Controller-specific parameters in their application. All Emitters controlled by this Controller use the same, specified user object.
| bool BS_NMSP::Controller::isEnabled | ( | ) | const |
Tests whether the Controller is currently enabled or disabled.
| void BS_NMSP::Controller::onRelease | ( | ) |
Callback for when the Controller is no longer needed.
Controllers are managed by a pool, and so need to be reused without being destroyed and recreated. This function overrides DeepMemoryPoolObject::onRelease to tidy up the parts of Controller that need it.
| int BS_NMSP::Controller::raiseEvent | ( | const String & | evt, | |
| const bstype * | args | |||
| ) |
Triggers an event in the Controller.
This function is for use by the user, hence the event is retrieved by name for convenience. It is currently up to the user to ensure that the number of arguments passed is correct.
| evt | name of the event to raise. | |
| args | array of values to pass as arguments. |
| void BS_NMSP::Controller::resume | ( | ) |
Resumes the Controller from a waiting state.
This is used to implement signal functionality. While signals are generally used to resume from a suspend, they will also resume a state if it is currently waiting.
| void BS_NMSP::Controller::setAngle | ( | bstype | facing, | |
| bstype | orbit | |||
| ) |
Set the angle of this Controller, in degrees.
| facing | the angle in which to orient the Controller and its Emitters. | |
| orbit | the angle by which to rotate the position of the Controller's Emitters. |
| void BS_NMSP::Controller::setDefinition | ( | ControllerDefinition * | def, | |
| bstype | x, | |||
| bstype | y, | |||
| bstype | angle | |||
| ) |
Set a Controller instance to use the specified ControllerDefinition.
Sets the Controller to use the given ControllerDefinition. You do not want to call this function directly: doing so will leave the Controller in an undefined state. Use Machine::createController instead.
| def | pointer to the ControllerDefinition to use to set the Controller up. | |
| x | initial x position | |
| y | initial y position | |
| angle | initial angle |
| void BS_NMSP::Controller::setEmitterMember | ( | int | emitter, | |
| int | member, | |||
| bstype | value, | |||
| float | time | |||
| ) |
Interpolate the specified member of an Emitter controlled by this Controller.
This function changes the specified variable smoothly over time. Unlike setMember, this is used for built-in member variables as well as user-defined ones. Hence, the first user variable is at index NUM_SPECIAL_MEMBERS (defined in bsCore.h).
| emitter | index of the emitter instance. | |
| member | index of the member variable. | |
| value | value to set it to. | |
| time | length of time (in seconds) to set the variable over. |
| void BS_NMSP::Controller::setEmitterMember | ( | int | emitter, | |
| int | member, | |||
| bstype | value | |||
| ) |
Set the specified member of an Emitter controlled by this Controller.
Unlike setMember, this is used for built-in member variables as well as user-defined ones. Hence, the first user variable is at index NUM_SPECIAL_MEMBERS (defined in bsCore.h).
| emitter | index of the emitter instance. | |
| member | index of the user member variable. | |
| value | value to set it to. |
| void BS_NMSP::Controller::setEmitterMemberState | ( | int | emitter, | |
| int | state | |||
| ) |
Set an Emitter's state.
Sets the state to the specified index. This is an internal method which uses index for speed reasons.
| emitter | index of the emitter instance. | |
| state | index of the state. |
| void BS_NMSP::Controller::setMember | ( | int | member, | |
| bstype | value | |||
| ) |
Set the specified member of the Controller.
This is for user-defined member variables. Built-in members such as position and angle are not set this way, thus index 0 is refers to the first user-defined member.
| member | index of the user member variable. | |
| value | value to set it to. |
| void BS_NMSP::Controller::setPosition | ( | bstype | x, | |
| bstype | y | |||
| ) |
| void BS_NMSP::Controller::setState | ( | int | state | ) |
Set the Controller state.
Sets the state to the specified index. This is an internal method which uses index for speed reasons.
| state | index of the state. |
| void BS_NMSP::Controller::setUserObject | ( | void * | userObject | ) |
Set the user-supplied object for this Controller.
| userObject | pointer to a user-supplied object, which is passed back into any emit function that this Controller's Emitters call. |
| void BS_NMSP::Controller::setX | ( | bstype | x | ) |
| void BS_NMSP::Controller::setY | ( | bstype | y | ) |
| void BS_NMSP::Controller::signal | ( | bstype | block | ) |
Removes a block from the Controller.
if the specified block exists in the Controller, it will be removed. This function helps implement signal functionality in scripts, for pausing scripts upon events.
| block | the value to act as a block. |
| void BS_NMSP::Controller::update | ( | float | frameTime | ) |
Update the Controller.
This function is for internal use.
| frameTime | the time interval since last update, in seconds. |


Vanilla JS
Banana
Kiwi
Orange
Melon
No item has been clicked
jQuery
Banana
Kiwi
Orange
Melon
No item has been clicked


#include <varargs.h> va_end(va_list ap);
Description
Use va_end
to declare that your program will not use the variable
argument list ap any further.
Returns
va_end
does not return a result.
Portability
The va_end
defined in varargs.h has the same syntax and
usage as the ANSI C version from stdarg.h.


Thymeleaf - Bootstrap Input Password
Home
(current)
About
Services
Contact
Username
Password
Submit form


8/17 email
Dear Faculty,
From those of us on the University Faculty Senate, we wanted to let you know the following:
On the University Faculty Senate, we are told that some CUNY campus administrations are essentially overfilling their colleges’ online courses (well past the normal course limits on those campuses), to save money it seems. We wanted to share this with the rest of the College of Staten Island faculty. We at CSI should all keep an eye on our own course size limits, and remember that the CUNY colleges are left to make their own decisions on current course caps. Indeed, one member of the UFS wrote the UFS listserv, “In light of [UFS] concerns regarding the determination of class size, I took the liberty of reaching out to the Office of Academic Affairs (OAA) for clarification on this matter. They indicated that the University [overall] has no official position on this issue; the colleges are making local decisions.”
Am I (Jean Halley) correct in thinking that so far I think our course caps have not been changed at the College of Staten Island? At any rate, we should all keep in mind that, if our administration acts like those on some other CUNY campuses, they might inflate class sizes without even letting us know. And we should remember that pushing back has had some success on other campuses. For example at MEC, a faculty person wrote, “They increased the class size to 50 and after some pushback, the deans of each school decreased it to 42 and some to 40. I am in the process of sending them the governance document that capped class sizes at 30.”
And at John Jay, it seems that this issue has been resolved for now, “as a result of a concerted effort at shared governance on the part of Department Chairs and the administration. A previous agreement (2013) regarding a maximum enrollment of 28 for online instruction will be honored; adjustments will be made to address sections that have already been allowed to exceed that limit. Those sections will be capped at current enrollment for fall 2020 to avoid penalizing already enrolled students.”
Further, I believe, faculty at QCC are working on a statement requiring the college limit online class sizes to 28. And at Kingsborough, the limit is 29 for all courses.
Also, this is helpful:
https://www.forbes.com/sites/dereknewton/2020/06/28/online-college-classes-should-have-no-more-than-12-students/#1310d0e23179
Thank you so much.


Networks – Extended
Networks used in real life, and where to go from here.
In action
Some popular companies and applications that use Twisted:
- ITA Software developed an airline reservation system for Air Canada that uses Twisted extensively
- Twilio – cloud telephony provider
- Apple’s Calendar Server
- LucasFilm – film and TV production company
- Launchpad – application that allows developers to develop and maintain software
- HipChat – hosted group chat that uses XMPP (Jabber)
- Justin.tv – live video streaming
- Tweetdeck – Twitter client for the browser
- NASA
- BuildBot – a continuous integration system
More success stories are on Twisted’s website.
Where to go from here
Twisted’s documentation contains a number of howtos, including web servers and clients, SMTP (mail) clients, DNS servers, and SSH servers. Complete list of tutorials and examples are listed here.
There are a number of excellent tutorials written by Dave Peticolas that don’t assume existing knowledge about networking or concurrency.
Gordon McMillan wrote a socket programming tutorial that makes use of Python’s socket library instead of Twisted.
Challenge yourself
- Serve static content with a Twisted server. A how-to here.
- Code a simple HTTP Proxy server using Twisted. An example here.
- Write an RSS feed aggregator with Python/Twisted. An example here.
Additional Python Libraries
There are a couple other popular network libraries written in Python:
Books, readings, presentations
- Book: Twisted Networking Programming Essentials
- Book: Foundations of Python Network Programming
- Book: Violent Python: A Cookbook for Hackers, Forensic Analysts, Penetration Testers and Security Engineers
- Presentation: Intro to Python Networking - UDP
- Presentation: Twisted Logic: Endpoints and why you shouldn’t be scared of Twisted
- Tutorial: Intermediate Twisted: Test-driven Networking Software
- Presentation: Twisted Matrix High Scores


{% extends 'homepage.html' %} {% block content %}
Created On {{lessons.created_at}} by {{lessons.created_by}}
{{comment.body}}
{{reply.reply_body}}


Ruby Enumerable Methods: Map
Jan 31, 2016
Say you want to take a set of data in ruby and iterate over each part to perform a certain task. There are several ways to do this, but today I’m going to discuss two of them: .map and .each. Now, I use .each all the time, and it’s one of my favorite (and easiest to use) iterative functions in Ruby. The enumerative .map method is almost identical to .each, with the exception that it creates a new array with the iterated items.
This is clearly stated in the Ruby docs, which state that:
Map invokes the given block once for each element of self. Creates a new array containing the values returned by the block. If no block is given, an Enumerator is returned instead.
An enumerator is simply an iteration that can be applied to an object. For example, if you call the .map method on an array without passing a command, it will simply iterate over each element.
A basic example of this method is as follows:
arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
new_array = arr.map { |num| num.to_s }
=> [“1”, “2”, “3”, “4”, “5”, “6”, “7”, “8”, “9”, “10”]
The difference between the above example and the .each iterator is that .map will create a new array while .each will only iterate over each object within the array.


Apprentice updated
Changes rejected
{% include "includes/account-name-number.html" %}Mel O'Connor
Change for review
There are changes to this apprentice's details that you need to review.
Review changes| Status | Live |
Overview |
|---|
| Training provider | Hackney Skills Solutions Ltd |
| Employer | Acme Coventry Ltd |
| Cohort reference | 98HXGFD |
Apprentice |
|---|
| Name | William Wing | |
| Unique learner number |<PHONE_NUMBER> | |
| Date of birth | 28 February 1997 | Apprenticeship training course | Level 2: Aeronautical engineering |
| Training start date | July 2018 | |
| Training end date | July 2020 | |
| Total cost of training | £6,555 | |
| Reference | Banbury site |


Ongraph
Pvt. Ltd.
Software Developer
Infosys Ltd.
Systems Engineer Trainee
Infosys Ltd.
Systems Engineer
Infosys Ltd.
Senior Systems Engineer
Infosys Ltd.
Senior Systems Engineer
Infosys Ltd.
Technology Analyst
Birlasoft Ltd.
Technical Leader
Birlasoft Ltd.
Lead Consultant
Birlasoft Ltd.
Lead Consultant


{% extends "course/course-base.html" %} {% load i18n %} {% block title %} {{flow_desc.title}} - {{ relate_site_name }} {% endblock %} {% block content %} {% if grade_info != None %} {% if grade_info.total_count or grade_info.optional_total_count %}
{# Translators: the following 5 blocks of literals make a sentence. PartI #} {% trans "You have" %} {% if grade_info.max_points != grade_info.max_reachable_points %} {# Translators: PartII #} {% trans "(so far)" %} {% endif %} {# Translators: PartIII #} {% blocktrans trimmed with provisional_points=grade_info.provisional_points|floatformat:"-2" max_points=grade_info.max_points|floatformat:"-2" %} achieved {{ provisional_points }} out of {{ max_points }} points. {% endblocktrans %} {% if grade_info.max_points != grade_info.max_reachable_points %} {# Translators: PartIV #} {% blocktrans trimmed %} (Some questions are not graded yet, so your grade will likely change.) {% endblocktrans %} {% else %} {# Translators: PartV #} {% blocktrans trimmed with points_percent=grade_info.points_percent|floatformat:"-2" %} (That's {{ points_percent }}%.) {% endblocktrans %} {% endif %}
{% if grade_info.total_points_percent < 100.001 %} {# otherwise we'll have trouble drawing the bar #}{% blocktrans trimmed with fully_correct_count=grade_info.fully_correct_count partially_correct_count=grade_info.partially_correct_count incorrect_count=grade_info.incorrect_count %} You have answered {{ fully_correct_count }} grading questions correctly, {{ partially_correct_count }} questions partially correctly, and {{ incorrect_count }} questions incorrectly. {% endblocktrans %} {% if grade_info.unknown_count %} {% blocktrans trimmed with unknown_count=grade_info.unknown_count %} The grade for {{ unknown_count }} questions is not yet known. {% endblocktrans %} {% endif %}
{% blocktrans trimmed with total_count=grade_info.optional_total_count fully_correct_count=grade_info.optional_fully_correct_count partially_correct_count=grade_info.optional_partially_correct_count incorrect_count=grade_info.optional_incorrect_count %} There are {{ total_count }} optional questions (not for grading). You have answered {{ fully_correct_count }} correctly, {{ partially_correct_count }} partially correctly, and {{ incorrect_count }} incorrectly. {% endblocktrans %} {% if grade_info.optional_unknown_count %} {% blocktrans trimmed with unknown_count=grade_info.optional_unknown_count %} The correctness for {{ unknown_count }} optional questions is not yet known. {% endblocktrans %} {% endif %}


The package uses environment variables to control the initialization procedure. The environment variables replace the system property entries used by Log4j.
For compability reasons the Log4j entry is recognised. Alternatively a environment variable style Log4Qt form can be used. The following entries are used:
false
the initialization procedure is skipped.
Environment variables are read during static initialisation on creation of the InitialisationHelper. They can be accessed by calling InitialisationHelper::environmentSettings().
All settings can also be made in the application settings under the group Log4Qt
. For example the environment variable LOG4QT_DEBUG
is equivalent to the setting Log4Qt/Debug
. If an environment variable is set it takes precedence over the application setting. Settings are only used, if an QApplication object is available, when the LogManager is initialised (see InitialisationHelper::setting() for details).


---
layout: post
title: Photographers For Inspiration - Helmut Newton
tags:
- Articles
- Black and White
- General Photography
- Helmut Newton
- inspiration
status: publish
type: post
published: true
meta:
series_part: "9"
aktt_notify_twitter: "yes"
_edit_lock: "1265035328"
aktt_tweeted: "1"
_edit_last: "2"
tt_auto_tweet_text: "New blog post: [TITLE] [URL] "
tt_auto_tweet: "false"
dsq_thread_id: "370398009"
---
One of my all time favorites. My work is heavily influenced by Helmut Newton. Like Salgado (which I admire but is not a giant influence in my own endeavors), when I think I am doing okay - I revisit some of Newtons vast archive of decades of photography. That sets me strait with how much further I have to grow and I get back to work again.
Helmut Newton is one of the few successful commercial photographers that blended his own vision for his art with a commercial commodity with no compromise. You either wanted Newton for your look or you didn't. If all you see is fantastically sexy women and men in some gorgeous settings that anyone could shoot you are missing Helmut Newton in a big big way. This guy is fantastically unimaginably good.
Take an in depth look at his work. Again, a book is way better than just surfing the web for acouple of his more well known images. They are good but they are not even close to being comprehensive or even representative of is vast body of personal, art, and commercial work. Buy a book or six, schedule yourself a few hours on the weekend with a nice bottle of wine and really take some time so see what is going on with this guy's images. There is of course the initial wow but what makes this guy so so very good is the depth and complexity of his work with such seemingly simple compositions.
I don't think I have seen a Helmut Newton image that does not exude lavishness, decadence, privvy, sexuality, and have at least a subtext of fetishistic polarities - pain, pleasure, want, desire, lust, love, tender, harsh. Amazing.
 I probably own more Helmut Newton monographs than any other photographer. One of my heros.
Enjoy
RB


| [Top] | [Contents] | [Index] | [ ? ] |
Summary of GDB
1. A Sample GDB Session
2. Getting In and Out of GDB
3. GDB Commands
4. Running Programs Under GDB
5. Stopping and Continuing
6. Examining the Stack
7. Examining Source Files
8. Examining Data
9. C Preprocessor Macros
10. Tracepoints
11. Debugging Programs That Use Overlays
12. Using GDB with Different Languages
13. Examining the Symbol Table
14. Altering Execution
15. GDB Files
16. Specifying a Debugging Target
17. Debugging Remote Programs
18. Configuration-Specific Information
19. Controlling GDB
20. Canned Sequences of Commands
21. Command Interpreters
22. GDB Text User Interface
23. Using GDB under GNU Emacs
24. The GDB/MI Interface
25. GDB Annotations
26. Reporting Bugs in GDB
27. Command Line Editing
28. Using History Interactively
A. Formatting Documentation
B. Installing GDB
C. Maintenance Commands
D. GDB Remote Serial Protocol
E. The GDB Agent Expression Mechanism
F. Target Descriptions
G. GNU GENERAL PUBLIC LICENSE
H. GNU Free Documentation License
Index
Please send FSF & GNU inquiries & questions to<EMAIL_ADDRESS>There are also other ways to contact the FSF.
These pages are maintained by the GDB developers.
Copyright Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
Verbatim copying and distribution of this entire article is permitted in any medium, provided this notice is preserved.
This document was generated by GDB Administrator on March, 27 2008 using texi2html


Back to Home
Request Funds
Answer a few quick questions:
How much do you need?
Ξ
$
How long do you need it?
1 month
2 month
3 month
4 month
5 month
6 month
7+ month
Quoted interest rate:
I agree to the
terms and conditions
Accept and Submit


DWR annotations can be used as a replacement as well as in conjunction with dwr.xml
.
Annotation support was written by Maik Schreiber.
To use DWR with annotations you need to specify a different DWR controller servlet in your web.xml
:
<servlet> <description>DWR controller servlet</description> <servlet-name>DWR controller servlet</servlet-name> <servlet-class>org.directwebremoting.servlet.DwrServlet</servlet-class> <init-param> <param-name>classes</param-name> <param-value> com.example.RemoteFunctions, com.example.RemoteBean </param-value> </init-param> </servlet>
The classes
servlet parameter must provide a comma-separated list of the fully-qualified class names of all annotated classes to be used with DWR.
The syntax for inner classes is to use '$' notation (as used by Class.forName()) rather than '.' notation (as used by import statements). For example, use java.util.Map$Entry
and not java.util.Map.Entry
.
To make a simple class available for remote access, use the @RemoteProxy and @RemoteMethod annotations:
@RemoteProxy public class RemoteFunctions { @RemoteMethod public int calculateFoo() { return 42; } }
Any method not annotated with @RemoteMethod will not be available for remote access.
To use a scripting name different from the class name, use the name
attribute of @RemoteProxy:
@RemoteProxy(name="Functions") public class RemoteFunctions { }
The @RemoteProxy has options available please see the Java docs for more details.
To make simple bean classes available for remote access, use the @DataTransferObject and @RemoteProperty annotations:
@DataTransferObject public class Foo { @RemoteProperty private int foo; public int getFoo() { return foo; } @RemoteProperty public int getBar() { return foo * 42; } }
To use more sophisticated converters see the converter
attribute of the @DataTransferObject annotation. Here is an example that configures the Hibernate converter and tells DWR to exclude propertyToExclude from serialization.
// Standard Annotation Configuration @DataTransferObject(converter=H3BeanConverter.class, params = @Param(name = "exclude", value = "propertyToExclude"))
Note: If you are using Spring you will need to use the type attribute:
// Spring Annotation Configuration @DataTransferObject(type="hibernate3", params = @Param(name = "exclude", value = "propertyToExclude"))


Handed out: September 11, 2017
Due: September 25 at 11:59pm
The topic of this project is sorting. The goal is two-fold: First, you will acquire hands-on experience with the implementation of an advanced sorting algorithm. Second, you will learn how to use sorting to solve a practical problem efficiently. In the first part, you will implement an enhanced version of quicksort. In the second part, you will use sorting to solve a real-world application.
You will implement an entropy-optimal sort Quick3wayBM.java
based
on keeping equal keys at both the left and right ends of the sub-array
a[lo,...,hi]
. Practically, you need to maintain indices that
enforce the following invariants:
p
and q
are such that
a[lo,...,p]
and a[q,...,hi]
are all equal to
a[lo]
i
is such that a[p+1,...,i-1]
are all less than a[lo]
j
is such that a[j+1,...,q-1]
are all greater than a[lo]
In your code, you should add to the inner partitioning loop code to swap
a[i]
with a[p+1]
(and increment p
) if
it is equal to v
, and to swap a[j]
with
a[q-1]
(and decrement q
) if it is equal to
v
, after the usual comparisons of a[i]
and
a[j]
with v
. The partitioning should terminate when
(i
> j
), and you should treat (i
== j
) as a special case where you should just simply advance
j
by one and break the loop. After the partitioning loop has
terminated, add code to swap the items with equal keys into position, whereby
you will have to swap(lo, j)
and then swap(lo+1, j-1)
... swap(j-k, p)
. Similarly you have to do the same for the
elements to the right of j
, swap(j+1, hi)
...
swap(j+w, q)
, whereby k
(resp. w
) are
the number of duplicate elements to the left (resp. right) of the sub-array.
In your code, you must implement the following improvements:
To find the median in Median-of-3 (resp. Tukey ninther) you should pick three
(resp. nine) elements spaced in your sub-array by
floor((N-1)/2)
(resp. floor((N-1)/8)
) starting from
the first element, where N
is the number of elements in the
sub-array. Note that the 3rd (resp. 9th) selected element may not be the last
element.
Your program should read the input from StdIn.java
. It should
process the input using the following command:
%java -cp .:stdlib.jar:algs4.jar Quick3wayBM < numbers1.txt
The file contains a list of numbers in the format (<number><space>). The first number is the number of elements in the file.
In each recursive sorting call of the array you have to output the following as a tuple following the exact format shown below. Your program should simply print the output to the command line. In the case you used the insertion sort just output:
(Insertion Sort, <lo>, <hi>)
Otherwise, you should output:
(<Improvement_used>, <lo>, <v>, <p>, <i>, <j>, <q>, <hi>)
where <Improvement_used>
will be either "Median of 3
"
or "Tukey Ninther
", depending on the case.
As an example of the former scenario, your program should output:
(Insertion Sort, 1, 4)
As two examples of the latter scenario, your program should output:
(Median of 3, 1, 10, 4, 15, 16, 20, 25) (Tukey Ninther, 6, 20, 4, 18, 17, 50, 70)
This output should take place before you move the equal values from the two ends of the array to the middle.
In addition to the above output, you will augment your
Quick3wayBM.java
code and submit another file that provides
a trace of the sorting steps, called Quick3wayBM_V.java
. It should
process the input just as above, with the command:
%java -cp .:stdlib.jar:algs4.jar Quick3wayBM_V < numbers1.txt
Print to standard output the elements, separated by spaces, in their current order, with one line per recursive sorting call. The first line should be the original order of the elements, and the last line should be the sorted order of the elements. At each step, output the elements after moving the equal elements in the two ends of the array to the middle.
Implement the following API. In addition, implement a main function that reads from the standard input a list of numbers separated by a space. The first number represents the number of integers to be sorted, followed by those integers.
public class Quick3wayBM { public static void sort(Comparable[] a) { ... } public static void sort(Comparable[] a, int lo, int hi) { ... // Insertion sort ... // Median of 3 ... // Use Tukey ninther as partitioning element ... // Bentley-McIlroy 3-way partitioning ... } }
With this document, there are three examples of numbers as a way for you to test
your code and make sure you are following the right format. These files are
numbers1.txt
, numbers2.txt
, and numbers3.txt
,
where each of them provide two different outputs, (output1.txt
,
outputV1.txt
), (output2.txt
, outputV2.txt
),
and (output3.txt
, outputV3.txt
) respectively. You can
find all example files here, or at the top of the page.
For your poetry class, you would like to tabulate a list of rhyming words. For example, if you had the following words (electrics, ethnic, clinic, coughed, laughed, metrics), your program should produce the following output:
[ cli|nic, eth|nic ] [ elec|trics, me|trics ] [ co|ughed, la|ughed ]
Write a program Rhyming.java
that reads in a sequence of words from
standard input and prints them out in the order specified above. Specifically, we
define here rhyming words as a group of words sharing a rhyme, and we define that
rhyme as being the longest possible suffix common to all words in the group. For
instance, in the example above, we do not consider "ic", "ics", or "ed" to be
rhymes because they are suffixes of longer common suffixes.
The output order is defined as follows.
Looking back at the previous example: the suffixes are nic (length=3), trics (length=5), and ughed (length=5). They appear in that order as a result of rule 1 (length 3 before length 5) and rule 2 (trics comes before ughed alphabetically). Finally, each set of rhyming words are listed alphabetically (rule 3). In addition, groups of rhyming words are separated by a newline. Note that the same word can rhyme with different groups of words. For instance: (friendly, lucky, murky, rapidly) would lead to the following output:
[ friendl|y, luck|y, murk|y, rapidl|y ] [ luc|ky, mur|ky ] [ frien|dly, rapi|dly ]
Again, while "y" is not a rhyme for the group (lucky, murky) (it is a suffix of the actual rhyme "ky"), it is a rhyme for the group (friendly, lucky, murky, rapidly), as it is the longest common suffix.
Your program should read from standard input, using StdIn.java
. It
should process the input using the following command line:
%java -cp .:stdlib.jar:algs4.jar Rhyming < list1.txt
The file contains a list of strings, one string per line. Your program should output to standard output all the words sorted as the example stated above. To facilitate the visual assessment of your result, start each new line (corresponding to a series of rhyming words in alphabetical order) with an opening square bracket followed by a space character and, symmetrically, terminate each new line with a space character followed by a closing square bracket. In addition, each word should contain a pipe symbol ("|") that indicates the beginning of the identified suffix. Again, refer to the examples above and to the solution files provided below.
Three test files are available with corresponding solutions. Use them to verify that
your code complies with all the guidelines listed above: list1.txt
,
list2.txt
, and list3.txt
, with loutput1.txt
,
loutput2.txt
, and loutput3.txt
, respectively. You can find
all example files here, or at the top of the page.
Submit your solution on or before Monday, September 25, 11:59pm. The submission
procedure is the same as for the first project. Inside your working directory for
this project on data (e.g. ~/cs251/project2
), create a folder in which
you will include all source code used and libraries needed to compile and run your
code. Specifically, your submission must include the following files:
Quick3wayBM.java
Quick3wayBM_V.java
Rhyming.java
stdlib.jar
readme.txt
(if needed)
DO NOT use absolute paths in your files since they will become invalid once submitted. Optionally, you can include a README file to let us know about any known issues with your code (like errors, special conditions, etc).
After logging into data.cs.purdue.edu
, please follow these steps to
submit your assignment:
%cd ~/cs251/project2
<your_first_name>_<your_last_name>
and copy
all the files needed to compile and run your code there.
~/cs251/project2
) execute the following turnin command:
%turnin -c cs251 -p project2 <your_first_name>_<your_last_name>
%turnin -v -c cs251 -p project2
-v
flag here, as otherwise your submission would
be replaced with an empty one.


Right Wing Network
Home
Campaign Trail
Archives
Interviews
[July 21st]
Kaidon Spare
[July 20th]
Spencer Landers
[July 20th]
Nicholas Richardson
[July 20th]
Franklin Hudson
Debates
[July 16th]
Nicholas Richardson - Vice Presidential Debate
[July 15th]
Kaidon Spare and GodofPolitics - Presidential Debate
Senate Sessions
[July 20th]
2nd Senate Session - Speaker Spencer Landers
[July 17th]
1st Senate Session - Speaker Spencer Landers
House Sessions
[July 19th]
2nd House Session - Speaker Franklin Hudson
[July 17th]
1st House Session - Speaker Franklin Hudson


Welcome to the Online Reading Group page. Here you can find a list of books being read by online members and the protocol you should follow for joining any one of the groups and read along with the other members.
Here are the books currently being read by online members:
The Design of Everyday Things is a best-selling book by cognitive scientist and usability engineer Donald Norman about how design serves as the communication between object and user.
Harry Potter and the Philosopher's Stone is the 1st fantasy novel written by British author J. K. Rowling which reveals a parallel magic world.
And Then There Were None is a mystery novel by English writer Agatha Christie, her best selling novel and described by her as the most difficult of her books to write.
Robinson Crusoe is a novel by Daniel Defoe, first published on 25 April 1719, which sees the main character who lived all alone for 28 years in an un-inhabited Island on the Coast of America.
Alice's Adventures in Wonderland is an 1865 novel written by English author Lewis Carroll which tells of a girl named Alice falling through a rabbit hole into a fantasy world populated by peculiar, anthropomorphic creatures.


Sections
Highlights
- There are three sections per week, led by CAs:
- Noa's section: Thursdays, 10:30am--11:50am, Gates B30
- Reyna's section: Thursdays, 4:30pm-5:50pm, Gates B03
- Shashwat's section: Fridays, 10:00am-11:20am, Gates B30
- During sections, we will go over the material covered in class that week, and work through practice problems.
- Sections are optional but highly recommended. Working through practice problems is one of the most effective ways to learn the material.
- You do not need to officially sign up for sections, you can just drop in to whichever is most convenient.
- Some particular topic you'd like to see covered in Section? Email us (marykw, rmhulett, silas, noaglasr) directly, or fill out the anonymous feedback form on the course home page.
Section Notes
- Section 1 (Week of 1/14): Asymptotic analysis, recurrence relations, divide and
conquer. [Problems] [Solutions] [Slides]
- Section 2 (Week of 1/21): More recurrence relations, randomized algorithms. [Problems] [Solutions] [Slides]
- Section 3 (Week of 1/28): BSTs, BucketSort, Sorting Lower Bounds. [Problems] [Solutions]
- Section 4 (Week of 2/4): Hashing and Graphs/BFS/DFS. [Problems] [Solutions]
- Section 5 (Week of 2/11): Midterm Review [Problems] [Solutions]
- Section 6 (Week of 2/18): More graphs! SCCs, Dijkstra, Bellman-Ford. [Problems] [Solutions]
- Section 7 (Week of 2/25): Dynamic Programming. [Problems] [Solutions]
- Section 8 (Week of 3/4): Greedy Algorithms
- Section 9 (Week of 3/11): Final Review


Chapter 10 Workshop Questions for Week 5
10.1 Questions
10.1.1 Short mathematical question - Determining rates of diffusion controlled quenching
The rate of diffusion (\(k_d\)) in solution is given by equation (10.1), where \(\eta\) is the viscosity of the solution.
\[\begin{equation} k_d = \frac{8RT}{3 \eta} \tag{10.1} \end{equation}\]
Determine the maximum possible rate of diffusion controlled quenching at 20 ºC in:
- water (\(\eta=\) 1.0016 mPa s)
- methanol (\(\eta=\) 0.594 mPa s)
(I will use UniDoodle to ask this in class)
10.1.2 Short mathematical question - Determining the effect of diffusion controlled quenching on emission intensity
What emisison intensity would you expect if 50 mM of a quencher quenches the emission of a chromophore dissolved in basic ethanol at 10 ºC, with natural lifetime of 13.2 ns and emission quantum yield, Φf, of 0.32, if the unqunched intensity is 35240.
\(\eta\)~EtOH, 10 ºC~ = 1.394 mPa s
(This will be a discussion question)
10.1.3 Short conceptual question - effect of temperature
YO-Pro-1 is quenched in the presence of molecular oxygen, as the temperature increases this quenching increases, what does this indicate about the mechanism of quenchign and why?
(This will be a discussion question)
10.1.4 Short conceptual question - change in behaviour on freezing
As the concentration of a species increases the wavelength of emission increases in the solution phase but this same shift in wavelength is not when the solution is frozen. What photochemical process may be occuring to explain this effect?
(This will be a discussion question)
10.1.5 Short conceptual question - static quenching
When in the presence of a quencher the intensity of emission of a chromophore (τ0 = 5.2 ns) was reduced from 4200 cps to 2100 cps at 25 ºC and 1800 cps at 10 ºC. What would the lifetime of the quenched chromophore be at 25 ºC?
(This will be a discussion question)
10.1.6 Short conceptual question - isoemissive point
As the concentration of pyrene dissolved in toluene increases a new broad band with a broad featureless spectrum is observed, which is from excimer emisison. What evidence is there that emission is only from single molecule and excimer emission and no other states?
How would the absorption spectrum change as the concentration increases?
10.1.7 Short conceptual question - static quenching
10-methylacridinium chloride (MAC) is quenced in the presence of adenosine monophosphate (AMP, figure (10.3)). The effect of quenching is enhanced by addition of sodium sulfate.
In a separate experiment the emssion of MAC is unaffected by addition of sodium sulfate (when not in the presence of AMP).
Suggest the mechanism of quenching, justifying this with reference to the experimental data.
(This will be a discussion question)
10.1.8 Long mathematical question - Quenching of emission of acridone
Acridone (figure 10.4)is found to be quenched in the presence of potassium iodide in aqueous solution at 26 oC. Solutions were maintained at constant ionic strength by use of KNO2, the KNO2 does not affect the emission intensity of the solution.
The following data were collected for the emission of acridone.
| [KI] / M | [KNO2] / M | Emission intensity / arb | τ / ns |
|---|---|---|---|
| 0 | 1.100 | 16580 | 17.60 |
| 0.040 | 1.060 | 3753 | 3.90 |
| 0.100 | 1.000 | 1566 | 1.80 |
| 0.200 | 0.900 | 721 | 0.95 |
| 0.300 | 0.800 | 446 | 0.64 |
| 0.500 | 0.600 | 242 | 0.39 |
| 0.800 | 0.300 | 121 | 0.25 |
Using an appropriate plot (or plots) determine if the quenching is static, dynamic or a combination of both mechanisms.
Determine any relevant quenching constants (kd and/or KS )
(This will be a discussion question)
10.2 Answers
10.2.1 Short mathematical question - Determining rates of diffusion controlled quenching
\[\begin{equation} k_d = \frac{8RT}{3 \eta} \tag{10.1} \end{equation}\]
Nominally this is simple but it needs some careful unit conversion, in water:
\[\begin{equation*} k_d = \frac{8 \times 8.31447 \textrm { J K$^{-1}$ mol$^{-1}$} \times 293 \textrm{ K}}{3 \times 1.0016 \times 10^{-3} \textrm{ Pa s}} \end{equation*}\]
\[\begin{equation*} k_d = \frac{8 \times 8.31447 \textrm { kg m$^2$ s$^{-2}$ K$^{-1}$ mol$^{-1}$} \times 293 \textrm{ K}}{3 \times 1.0016 \times 10^{-3} \textrm{ kg m$^{-1}$ s$^{-2}$ s}} \end{equation*}\]
\(k_d= 6.49 \times 10^6\) mol\(^{-1}\) m\(^3\) s\(^{-1}\)
\(k_d= 6.49 \times 10^9\) mol\(^{-1}\) dm\(^3\) s\(^{-1}\)
in methanol \(k_d= 1.09 \times 10^{10}\) mol\(^{-1}\) dm\(^3\) s\(^{-1}\)
10.2.2 Short mathematical question - Determining the effect of diffusion controlled quenching on emission intensity
Combining equations (5.3) and (5.4), we get equation (6.1), see Section 6.1.1.
This means we can rearrange to give:
\[\begin{equation*} \tau = \tau^0 \phi_f = 13.2 \textrm{ ns} \times 0.32 \end{equation*}\]
\(\tau_{unquenched}\) = 4.2 ns (note this will be refered to as \(\tau_0\) from this point on).
From equation (10.1) in section 10.1.1 we can determine \(k_d = 4.50 \times 10^9\) mol\(^{-1}\) dm\(^3\) s\(^{-1}\).
The Stern-Volmer equation (10.2) shows how the concentration of a quencher affects the intensity, lifetime or quantum yield:
\[\begin{equation} \frac{\tau_0}{\tau}=\frac{\phi_0}{\phi}=\frac{I_0}{I}=1+ k_q \tau_0 \tag{10.2} \end{equation}\]
Rearranging
\[\begin{equation*} I = \frac{I_0}{1 + k_q \tau_0 [Q]}= \frac{3520}{1+0.945} \end{equation*}\]
I = 18k
10.2.3 Short conceptual question - effect of temperature
This would indicate dynamic quenching, the rate of diffusion control is proporitional to temperature, equation (10.1) in section 10.1.1, the higher the rate the more collisional deactivation. A static quenching is an equilibrium complex and the weak intermolecular bonding is broken as temperature increases and so static quenching decreases with increasing temperature.
10.2.4 Short conceptual question - static quenching
Ok - more than a hint in the question title, but why?
Here as the temperature is decreased the amount of quenching increases, this indicates formation of a non-emissive static complex held togehter by a weak intermoleular bond. (Figure 10.5).
Since the fluorophore now exists in one of two states (the unquenched free choromophore and the non-emissive bound chromophore) any fluorescence observed is unquenched and so the measured lifetime remains the same.
10.2.5 Short conceptual question - static quenching
Again I give away the mechanism in the question title, but why is it static?
The principle reason is the sodium sulfate, it is clearly not quenching as there is no effect when it is added to the MAC solution, and there is no reason it should affect the rate of diffusion when combined with AMP.
Therefore we are left to conclude it is static quenching, but what is the role of the sulfate. This goes back to the non-ideality of ionic solutions, and the addition of a salt is almost certainly providing an ionic atmosphere that is helping to move the equilibrium to the complex, by making this state more stable.
Having a constant ionic strength is vitally important in experiments (not just electrochemistry), and the role of the KNO2 in Question 10.1.8 is just there to ensure the ionic strength of the system remains constant.
10.2.6 Long mathematical question - Quenching of emission of acridone
Since the plot of \(\frac{I_0}{I}\) vs [Q] is non linear this would likely indicate that quenching is a combination of both static and dynamic quenching.
\[\begin{equation*} \frac{I_0}{I}=(1 + K_s [Q])(1 + k_q \tau _0 [Q]) \end{equation*}\]
Given we have lifetime data we can easily determine the dynamic rate constant by plotting \(\frac{\tau_0}{\tau}\) vs [Q] (Equation (10.2)).
From this KS = 1.19 and kq = 4.94 × 109 M-1 s-1
I solved this in python and the notebook is available on request.


Some stuff -- yeah? nah... well ok then, but what to do with it all? I guess sell it to the feds.
Some stuff -- yeah? nah... well ok then, but what to do with it all? I guess sell it to the feds.
Some stuff -- yeah? nah... well ok then, but what to do with it all? I guess sell it to the feds.
Some stuff -- yeah? nah... well ok then, but what to do with it all? I guess sell it to the feds.
I think something is a little smelly!
I won though!
How is this happening today?


Blue Community Assessment
{{About Section}}
{{Geography}}
|
Cover |
{{Cover}} |
|
About this Section |
{{About this Section}} |
|
71. What is the percentage of sewage from site receiving treatment (to primary, secondary, (wastewater management) tertiary levels)? |
{{71. What is the percentage of sewage from site receiving treatment (to primary, secondary, (wastewater management) tertiary levels)?}} |
|
71a. 🔢 |
{{71a. 🔢}} |
|
71b. 🔗Source |
{{71b. 🔗Source}} |
|
72. What is the percentage of tourism accommodations using sewage treatment systems? |
{{72. What is the percentage of tourism accommodations using sewage treatment systems?}} |
|
72a. 🔢 |
{{72a. 🔢}} |
|
72b. 🔗Source |
{{72b. 🔗Source}} |
|
73. What is the volume of waste produced by the community (tonnes) annually? |
{{73. What is the volume of waste produced by the community (tonnes) annually?}} |
|
73a. 🔢 |
{{73a. 🔢}} |
|
73b. 🔗Source |
{{73b. 🔗Source}} |
|
74. What is the volume of waste recycled (tonnes) per year? |
{{74. What is the volume of waste recycled (tonnes) per year?}} |
|
74a. 🔢 |
{{74a. 🔢}} |
|
74b. 🔗Source |
{{74b. 🔗Source}} |
|
75. What is the volume of waste to landfill (tonnes) per year? |
{{75. What is the volume of waste to landfill (tonnes) per year?}} |
|
75a. 🔢 |
{{75a. 🔢}} |
|
75b. 🔗Source |
{{75b. 🔗Source}} |
|
76. Reference Images for this Section |
{{76. Reference Images for this Section}} |
|
76a. 📸 |
{{76a. 📸}} |
|
76b. 📸 |
{{76b. 📸}} |
|
76c. 📸 |
{{76c. 📸}} |
|
Last Edited |
{{Last Edited}} |
|
Last Edited By |
{{Last Edited By}} |
|
Notes for Stakeholders |
{{Notes for Stakeholders}} |


We launched three years ago and loved it every second. At the time I was just a man with an ideea but 2 weeks later I was a man with a plan. We jumped on this adventure and learned a lot along the way. Two days after launching we had our first client. In what we do, being creative is crucial. And we love the moments when we have to make our brain work and produce new, crazy, beautiful ideas.
Find moreWe launched three years ago and loved it every second. At the time I was just a man with an ideea but 2 weeks later I was a man with a plan. We jumped on this adventure and learned a lot along the way. Two days after launching we had our first client. In what we do, being creative is crucial. And we love the moments when we have to make our brain work and produce new, crazy, beautiful ideas.
We launched three years ago and loved it every second. At the time I was just a man with an ideea but 2 weeks later I was a man with a plan. We jumped on this adventure and learned a lot along the way. Two days after launching we had our first client. In what we do, being creative is crucial. And we love the moments when we have to make our brain work and produce new, crazy, beautiful ideas. We launched three years ago and loved it every second. At the time I was just a man with an ideea but 2 weeks later I was a man with a plan. We jumped on this adventure and learned a lot along the way. Two days after launching we had our first client. In what we do, being creative is crucial. And we love the moments when we have to make our brain work and produce new, crazy, beautiful ideas. We launched three years ago and loved it every second. At the time I was just a man with an ideea but 2 weeks later I was a man with a plan. We jumped on this adventure and learned a lot along the way.
We launched three years ago and loved it every second. At the time I was just a man with an ideea but 2 weeks later I was a man with a plan. We jumped on this adventure and learned a lot along the way. Two days after launching we had our first client. In what we do, being creative is crucial. And we love the moments when we have to make our brain work and produce new, crazy, beautiful ideas. Two days after launching we had our first client.
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Est blanditiis dolorem culpa incidunt minus dignissimos deserunt repellat aperiam quasi sunt officia expedita beatae. Lorem ipsum dolor sit amet, consectetur adipisicing elit. Est blanditiis dolorem culpa incidunt minus dignissimos. Est blanditiis dolorem culpa incidunt minus dignissimos.
Officia expedita beatae cupiditate, maiores nostrum, repudiandae, reiciendis facere nemo! Lorem ipsum dolor sit amet, consectetur adipisicing.
"If the sight of the blue skies fills you with joy, if a blade of grass springing up in the fields has power to move you, if the simple things of nature have a message that you understand, rejoice, for your soul is alive."
Weddings, celebrations, parties - we can decorate and make your event more beautiful and unforgetable with special floral arrangements and decorations.
You can have the delivery at your choosen place any day of the week, from monday to sunday, from 9 AM to 6 PM, with punctuality and responsibility
We will help you make someone's birthday, graduation, celebration and any day more bright and beatiful with a special flower bouquet and personal note.
We partnered with the best flower farms in the country, in order to make sure the flowers you get are the freshest, eco-friendly, organic flowers possible.


Macintosh512k
About Me
My Projects
About Me
My Skills
HTML (5 Years)
CSS (3 Years)
JS (Still a noob)
Shell (idk man)
My Projects
Nothing
really
cool here
Davinci


--- layout: selenium_example_page task_id: 2 lang: en task_name: Checkbox elements exercise-scenarios: - name: User can mix colors steps: - User opens "Exercise 2" page - User selects RED - User selects BLUE - Verify result is PINK - name: User can activate comments steps: - User opens "Exercise 2" Page - Verify if comments text field is disabled - User activates comments - Verify if comments text field is enabled ---


[gecode-users] Unexpected propagation/search behaviour
Christian Schulte
schulte at imit.kth.se
Mon Jan 23 10:40:57 CET 2006
This will actually be most likely the cause for ypur problems. Not only is
it dangerous to not check for the status but actually in your case the very
fact that failure has been dected gets lost!
Christian
--
Christian Schulte, http://www.imit.kth.se/~schulte/
-----Original Message-----
From: users-bounces at gecode.org [mailto:users-bounces at gecode.org] On Behalf
Of Mikael 'Zayenz' Lagerkvist
Sent: Monday, January 23, 2006 7:35 AM
To: Lars Otten
Cc: users at gecode.org
Subject: Re: [gecode-users] Unexpected propagation/search behaviour
Hi,
On 1/23/06, Lars Otten <ottenl at student.chalmers.se> wrote:
> propagate(Space* home) {
> for (int i=0; i<n; ++i) {
> //... do stuff for x and y
> if (z[i].assigned() && <z[i] not yet treated> ) {
> //... some preparations, like creating IdxView instances
> Element::ViewDom<IntView,IntView>::post(home,z,z.size(),x[i],z[i]);
> Element::ViewDom<IntView,IntView>::post(home,z,z.size(),y[i],z[i]);
> }
> }
> //...
> }
I have one comment on the above code. When calling the post-methods, it is
very important to always check the return-value for possible failure. The
code should look something like the following.
if (z[i].assigned() && <z[i] not yet treated> ) {
//... some preparations, like creating IdxView instances
if(Element::ViewDom<IntView,IntView>::post(home,z,z.size(),x[i],z[i])
== ES_FAILED)
return ES_FAILED;
if(Element::ViewDom<IntView,IntView>::post(home,z,z.size(),y[i],z[i])
== ES_FAILED)
return ES_FAILED;
}
When a failure is detected, the space may no longer be in a consistent
state. Therefore it is important to stop computing with it.
Cheers,
Mikael
--
Mikael 'Zayenz' Lagerkvist, http://www.imit.kth.se/~zayenz/
_______________________________________________
Gecode users mailing list
users at gecode.org https://www.gecode.org/mailman/listinfo/gecode-users
More information about the gecode-users
mailing list


Simon Li
Simon Li
Kubernetes is an open-source platform designed to automate deploying, scaling, and operating application containers.
docker run postgres
docker run -p 4064:4064 openmicroscopy/omero-server
docker run openmicroscopy/omero-web
docker run nginx
docker-compose
version: "3"
services:
database:
image: "postgres:9.6"
environment:
- POSTGRES_PASSWORD=SeCrEtPaSsWoRd
networks:
- omero-network
volumes:
- "database-volume:/var/lib/postgresql/data"
omeroserver:
image: "openmicroscopy/omero-server:5.4.0"
environment:
- CONFIG_omero_db_pass=SeCrEtPaSsWoRd
networks:
- omero-network
ports:
- "4063:4063"
- "4064:4064"
volumes:
- "omero-volume:/OMERO"
omeroweb:
image: "openmicroscopy/omero-web-standalone:master"
environment:
- OMEROHOST=omeroserver
networks:
- omero-network
ports:
- "4080:4080"
networks:
omero-network:
volumes:
database-volume:
omero-volume:
A containerised app, e.g. OMERO.web, omero-ms-thumbnail.


Account locked
Click "Save" to unlock account
Cannot start with a number
No special characters except underscore
Password must between {{modalCtrl.minPasswordLength}} – {{modalCtrl.maxPasswordLength}} characters


[Summary] [Package List] [Test Cases]
| Tests | Errors | Failures | Skipped | Success Rate | Time |
|---|---|---|---|---|---|
| 34 | 0 | 0 | 0 | 100% | 0.964 |
Note: failures are anticipated and checked for with assertions while errors are unanticipated.
[Summary] [Package List] [Test Cases]
| Package | Tests | Errors | Failures | Skipped | Success Rate | Time |
|---|---|---|---|---|---|---|
| view | 2 | 0 | 0 | 0 | 100% | 0.081 |
| controller | 1 | 0 | 0 | 0 | 100% | 0.001 |
| com.entity.motionlesselements | 8 | 0 | 0 | 0 | 100% | 0 |
| com.entity.mobileelements | 13 | 0 | 0 | 0 | 100% | 0.488 |
| model | 5 | 0 | 0 | 0 | 100% | 0.202 |
| com.databaseconnection | 1 | 0 | 0 | 0 | 100% | 0.001 |
| com.collisionshandler | 3 | 0 | 0 | 0 | 100% | 0.19 |
| entity | 1 | 0 | 0 | 0 | 100% | 0.001 |
Note: package statistics are not computed recursively, they only sum up all of its testsuites numbers.
| Class | Tests | Errors | Failures | Skipped | Success Rate | Time | |
|---|---|---|---|---|---|---|---|
| ViewPanelTest | 1 | 0 | 0 | 0 | 100% | 0.08 | |
| ViewTest | 1 | 0 | 0 | 0 | 100% | 0.001 |
| Class | Tests | Errors | Failures | Skipped | Success Rate | Time | |
|---|---|---|---|---|---|---|---|
| DirtTest | 2 | 0 | 0 | 0 | 100% | 0 | |
| ExitDoorTest | 2 | 0 | 0 | 0 | 100% | 0 | |
| PathTest | 2 | 0 | 0 | 0 | 100% | 0 | |
| WallsTest | 2 | 0 | 0 | 0 | 100% | 0 |
| Class | Tests | Errors | Failures | Skipped | Success Rate | Time | |
|---|---|---|---|---|---|---|---|
| DiamondTest | 2 | 0 | 0 | 0 | 100% | 0 | |
| EnemyTest | 3 | 0 | 0 | 0 | 100% | 0.377 | |
| PlayerTest | 6 | 0 | 0 | 0 | 100% | 0.111 | |
| StoneTest | 2 | 0 | 0 | 0 | 100% | 0 |
| Class | Tests | Errors | Failures | Skipped | Success Rate | Time | |
|---|---|---|---|---|---|---|---|
| DAOMapTest | 1 | 0 | 0 | 0 | 100% | 0.127 | |
| ModelTest | 4 | 0 | 0 | 0 | 100% | 0.075 |
| Class | Tests | Errors | Failures | Skipped | Success Rate | Time | |
|---|---|---|---|---|---|---|---|
| DBPropertiesTest | 1 | 0 | 0 | 0 | 100% | 0.001 |
| Class | Tests | Errors | Failures | Skipped | Success Rate | Time | |
|---|---|---|---|---|---|---|---|
| CollisionsHandlerTest | 3 | 0 | 0 | 0 | 100% | 0.19 |
[Summary] [Package List] [Test Cases]
| testPlayerIsAlive | 0.061 | |
| testDidPlayerWin | 0.023 | |
| testDiamondCounterPlayer | 0.01 | |
| testPlayer | 0.009 | |
| testMovePlayer | 0.004 | |
| testEntityBasicCharacteristics | 0.004 |
| testGetContentOfMap | 0.046 | |
| testGetNumberOfDiamondsNeeded | 0.029 | |
| testLimitLoadingMap | 0 | |
| testContentOfMap | 0 |


Toggle navigation
Cover to Cover
Account
Book Bag
Login / Register
Administrative Options
Add
Delete
Edit
Add Book
Title:
Description:
ISBN:
Publisher:
Format:
EBook
Print Book
Date Published:
Edition:
Number of pages:
Author:
Genre:
Price:
Image URL:
Submit
Delete Book
Catching Fire
Divergent
The Rainbow Fish
The Lord of the Rings
Water for Elephants
Harry Potter and the Sorceror's Stone
Harry Potter and the Prisoner of Azkaban
Harry Potter and the Half Blood Prince
Delete
Edit Book Info
Book:
Catching Fire
Divergent
The Rainbow Fish
The Lord of the Rings
Water for Elephants
Harry Potter and the Sorceror's Stone
Harry Potter and the Prisoner of Azkaban
Harry Potter and the Half Blood Prince
Title:
Description:
ISBN:
Publisher:
Format:
EBook
Print Book
Date Published:
Edition:
Number of pages:
Author:
Genre:
Price:
Image URL:
Submit


Goal Driven Mixed-Initiative Systems with Collaborative Filtering
Mixed-initiative systems combine the efforts of human actors with artificial agents to improve the performance of both participants in some mutual functionality. For example, an intelligent search application can be viewed as a mixed-initiative system where a human uses token strings or a special query language to enact searches that are carried out by an ensemble of statistical models which deliver intelligent results. In return, they benefit from the positive feedback of the user, e.g. which links are clicked, or how many queries it takes to find a result.
A mixed-initiative system is said to be goal-driven when predefined goals are used to affect the behavior of both the human user and the underlying agent. In our search example, we could talk about an “academic goal” where the user is specifically looking for research materials. In this case, the types of queries made by the user will be influenced by this goal, and the results or domain of the agent should also take this goal into account. Additionally, the agent should seek to recover from failures or anomalies by generating its own goals. By using goals, we can effectively communicate bidirectional intent as well as explain failure in mixed-initiative systems.
A third, interesting dimension comes into play when there are many human users participating in a mixed-initiative system. Namely, user behavior coupled with their goals creates a latent semantic network which can be accessed to improve mixed-initiative interactions through recommendation algorithms. In the next sections, I will describe the novel application of collaborative filtering algorithms improved with goal-dimensionality to mixed-initiative systems to both allow agents to provide other human help to a human user (goal combination) as well to elicit or change the goals of a human user in real time to improve their efficacy (goal generation).
Collaborative Filtering for Goal Combination
Consider an opening scene from the 1970s TV version of Mission Impossible: Peter Graves pours over the dossiers of IMF agents as the camera hones in on their skills: weapons-expert, master of disguise, a navy diver. He carefully selects the perfect team for his mission as the burnt remnants of the mission tape smolder on the table. He knows that he will only succeed in his mission if he combines the expertise of his agent in a specific mission-oriented configuration.
So too can our goal driven, mixed-initiative systems assist human users on their efforts, particularly in multi-domain systems. Each human user (or even possibly agent or model) has an expertise that is expressed through the goals of each user. A financial analyst will have goals related to their particular expertise, just like a language expert might also have goals related to a particular region. However, because a human user has many, changing goals- we can build a goal-to-goal similarity matrix using the goal-vector of the user; this matrix is the basis of item-centric collaborative filtering algorithms.
The goal similarity matrix will produce clusters of related goals. The system can then use the goal cluster to discover other human analysts to recommend to the original user either in a passive context (provide hints based on the behavior of the other similar users) or in an active context- directly connecting the recommended user to the original user. Team selection can also be made on this basis- selection of members from related clusters to improve the overall effectiveness of the human team. Because recommended users will have different goals than the original user, this activity can be seen as goal combination. Either way, the human user will experience highly personalized guidance on part of the system through these recommendations.
Collaborative Filtering for Goal Generation
As mentioned in the previous section, a human analyst (or agent’s) goals change over time- either as (1) the result of a new mission, (2) a change in world knowledge or the environment, or (3) in order to explain or recover from failure. It would be useful for a mixed-initiative system to anticipate these changes in goals particularly in order to adapt to (2) or (3). This will lead to a much smoother transition between goals, as well as improve the efficacy of a system that has to respond to a dynamic environment.
Changing the goals of the analyst in real-time is possible through the novel use of our goal-based collaborative filtering with an additional dimension- the changing state of the behavior of the user. Our similarity matrix is now not only goal-to-goal, but instead goal-to-goal-to-state. This similarity matrix can then be decomposed to a series of class based goal-to-state similarity matrices. As the state of the user changes (e.g. the nature or classification of the behavior in terms of nearest-similar goals) these more similar goals are presented to the user in order to influence the user’s behavior towards more fruitful behavior (or to allow the user to avoid potential pitfalls when they recognize an ineffective goal).
In this manner, the system can affect the behavior of the user before the user is aware of the need for a change in goals. This results in a highly personalized system that is bidirectional. Not only can the system use the behavior state to recommend goals and influence human behavior, the system can also use the goals to modify the results based on positive feedback from other users with similar goals and similar behavior. For instance, the selection of a recommended goal is a positive feedback mechanism that can be used in active learning when computing goal-state similarity matrices.


{% extends "partials/tooltips/base.html" %}
{% block title %}
Party's Certificate
{% endblock %}
{% block inner %}
The Party’s Certificate certifies that you and your spouse are aware of your duties
under the Divorce Act (Canada) throughout the process of applying for divorce.
{% endblock %}
{% block label %}
{% if text %}{{ text }}{% else %}Party's Certificate{% endif %}
{% endblock %}


{{event.modified}}
{{item.date}}
You do not have any friend activity to show
You do not have any friends


Enter the email address and password you used to create your Innovation Funding Service account.
If you haven’t used this service before you must create an account, even if you already have an existing account with Innovate UK.
When you create an account you can:
Machine learning in robots
Machine learning in robots
Machine learning in robots
Machine learning in robots
Mobile Phone Data for Logistics Analytics
Additive manufacturing
Machine learning in robots
The potential for glucose based contact lens monitoring in the management of type two diabetes
Machine learning in robots
Machine learning in robots
Machine learning in robots
Not submitted
3456
Aptrans Ltd
Project start date:
4 November 2016
Duration:
51 months
£203,567
This is the level of cost detail that the assessors will see during the assessment process
| Partner | Total costs | % Grant | Funding sought | Other public sector funding | Contribution to project | |||||
|---|---|---|---|---|---|---|---|---|---|---|
| Total | £280,000 | £280,000 | £280,000 | £280,000 | £280,000 | |||||
|
Aptrans Ltd Lead partner |
£100,000 | 70% | £60,000 | £10,000 | £30,000 | - | - | - | - | - |
|
Biotech corp Partner |
£150,000 | 50% | £60,000 | £15,000 | £75,000 | - | - | - | - | - |
|
University of Cardiff Partner |
£30,000 | 100% | £30,000 | N/A | N/A |
| Partner | Total | Labour | Overheads | Materials | Capital usage | Subcontracting cost | Travel and subsistence | Other Costs | ||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Total | £450,983 | |||||||||||||||
|
Aptrans Ltd Lead partner |
£257,033 | £126,207 | £86,167 | £44,659 | £257,033 | £126,207 | £86,167 | £44,659 | - | - | - | - | - | - | - | - |
|
Biotech corp Partner |
£0 | £0 | £0 | £0 | £0 | £0 | £0 | £0 | - | - | - | - | - | - | - | - |
|
University of Cardiff Partner |
£38,950 | £8,600 | £19,350 | £11,000 | £38,950 | £8,600 | £19,350 | £11,000 |
This application can be submitted with these project costs.
You will not be able to submit this application until the research participation is 30% or less.
If you need to provide more information to support your answer, you can include an appendix, e.g. a project plan
You should include only supporting information in the appendix. You shouldn’t use it to provide responses to the question.
You can include a Gantt chart of your proposed project
The appendix must:
If you need to provide more information to support your answer, you can include an appendix, e.g. a diagram of your innovation
You should include only supporting information in the appendix. You shouldn’t use it to provide your responses to the question.
The appendix must:
If you need to provide more information to support your answer, you can include an appendix, e.g. details of subcontractors
You should include only supporting information in the appendix. You shouldn’t use it to provide your responses to the question.
You can describe the expertise and track record of project partners and sub-contractors. Academic collaborators can include details of their research achievements.
The appendix must:
You should include only supporting information in the appendix. You shouldn’t use it to provide your responses to the question.
Guidance for this section needs to be created
You should include only supporting information in the appendix. You shouldn’t use it to provide your responses to the question.
Guidance for this section needs to be created
No file currently uploaded
No file currently uploaded
Upload the assessor feedback page
The Project aims to identify, isolate and correct an issue that has hindered progress in this field for a number of years. Identification will involve the university testing conditions to determine the exact circumstance of the Issue. Once Identification has been assured we will work to Isolate the issue but replicating the circumstances in which it occurs within a laboratory environment. After this we will work with our prototyping partner to create a tool to correct the issue. Once tested and certified this will be rolled out to mass production.
Wastage in our industry can be attributed in no small part to one issue. To date businesses have been reluctant to tackle that problem and instead worked around it. That has stifled progress.
The end result of our project will be a novel tool to manage the issue and substantially reduce the wastage caused by it.
The Project aims to identify, isolate and correct an issue that has hindered progress in this field for a number of years. Identification will involve the university testing conditions to determine the exact circumstance of the Issue. Once Identification has been assured we will work to Isolate the issue but replicating the circumstances in which it occurs within a laboratory environment. After this we will work with our prototyping partner to create a tool to correct the issue. Once tested and certified this will be rolled out to mass production.
Within the Industry one issue has caused progress in the field to be stifled. Up until now any advancement has been made by working around this anomaly.
We propose to tackle the situation head on and develop a tool that will circumvent the problem entirely allowing development to
The issue affects the entire field, the market value of which is significant, and accounts for a percentage of its annual overhead. A tool to reduce that amount by a significant proportion would be taken up by the entire industry.
At this time no other solutions are available or near market giving us the leading edge on market share.
Manufacture and development could remain in the United Kingdom with an international export market.
The issue affects the entire field, the market value of which is significant, and accounts for a percentage of its annual overhead. A tool to reduce that amount by a significant proportion would be taken up by the entire industry.
At this time no other solutions are available or near market giving us the leading edge on market share.
Manufacture and development could remain in the United Kingdom with an international export market.
The tool will give the consortium the leading edge on the technology as currently no one else is close to considering developing a solution.
The Industry will be able to reduce wastage by a significant degree and pass those savings on to the consumer or reinvest into advancing the field.
Inside 2 years it is estimated that a very large sum of money can be recouped by using our solution
Our Academic partner has developed a technique to identify the precise cause of the issue and have been able to demonstrate it at a small scale. Taking this information they will scale up the experiment to a percentage of industrial scale to confirm.
We will take this data and engineer a solution to isolate the problem we will then collude with our fabrication partner to design and prototype a tool to correct the obstacle.
The project is based on Manchester?s novel IP that, for the first time, allows SLM to be conducted without any need for anchors/supports. A search of the literature has established that the advances proposed in this project on which RAMP are based are not available via any commercially available process. In addition, the development and supply of tailored materials by Empire and a dedicated high temperature rig by Ludlow will involve further, critical degrees of innovation that will help to build a portfolio of IP to enhance commercial exploitation. NB. RAMP does not simply reduce stresses by working at higher temperatures; it involves a novel step based on manufacturing engineering and material science that completely eliminates stresses.
Three principal risks exist at this stage:
The team consists of: Us - We have been supplying engineering solutions to the industry for a number of years and have been principal deliverers for various advancements within the field. We are a suitably sized team capable of developing flexible solutions to a wide variety of clients internationally.
Academic ? the principal investigator and his team have been studying the issue for a number of years and have qualifications across the spectrum that apply to the field. Together they have already identified several efficiencies that can be made within the industry.
The Fabricators ? Are a leading team within complex engineering fabrication. They have work on multiple high budget engineering solutions and consist of a team of people with many years? experience in a range of industries
The amount of money needed to complete this project is large.
The academic phase will require the acquisition of several pieces of lab equipment and the employ of additional graduates to ensure the experiments run smoothly.
The Materials and use of the fabricators equipment will account for approximately some of the budget.
The time and expertise required across all 3 partners to complete each phase will amount to the lion share of the cost
.Although steps are under way to get this project off the ground, investment by Innovate UK will stimulate Industry leads to supply additional resource funding and use of their facilities as required to advance the progress of this project.
UK Investment will ensure that we are able to retain the onward manufacture internally instead of needing to create international deals taking work and profit out of the country.
Your submitted spend profile will be used as the base for your project spend over the following financial years.
| Financial year (April to March) |
Project spend |
|---|---|
| 2016 to 2017 | £260,000 |
| 2017 to 2018 | £312,000 |
| 2018 to 2019 | £312,000 |
| 2019 to 2020 | £52,000 |


 Register here
Non hai un account ? Registrati qui
Don't have an account? Register here
Don't have an account? Register here
Non hai un account ? Registrati qui
Don't have an account? Register here


Toggle navigation
oncoEnrichR
0.9.7
Reference
Changelog
Changelog
Source:
NEWS.md
Version 0.9.6 (May 12th 2021)
Added
Cancer hallmarks evidence
Fixed
Minor bugs (background query specificiation)
Data upgrade
Drug retrieval from Open Targets Platform (v2021.04)
Version 0.9.4 (April 25th 2021)
Fixed
Cleaned Excel output
Version 0.9.3 (April 24th 2021)
Added
Option to
onco_enrich
that may ignore cytosol as a structure in subcelluar heatmap
Interactive table with recurrent somatic variants (TCGA) overlapping query set in the
SNVs/InDels
section
Barplot for subcellular locations
Barplot for most significant GO terms enriched in query set
Fixed
Bug in PPI’s for query sets with few/none interactions
Data upgrade
MSigDB/GO/Reactome (MSigDB v7.4), UniProt (2021_02)
Contents


We're sorry but this test page doesn't work properly without JavaScript enabled. Please enable it to continue.


Gensim is a free Python library designed to automatically extract semantic topics from documents, as efficiently (computer-wise) and painlessly (human-wise) as possible.
Gensim is designed to process raw, unstructured digital texts (“plain text”).
The algorithms in Gensim, such as Word2Vec
, FastText
,
Latent Semantic Analysis (LSI, LSA, see LsiModel
), Latent Dirichlet
Allocation (LDA, see LdaModel
) etc, automatically discover the semantic structure of documents by examining statistical
co-occurrence patterns within a corpus of training documents. These algorithms are unsupervised,
which means no human input is necessary – you only need a corpus of plain text documents.
Once these statistical patterns are found, any plain text documents (sentence, phrase, word…) can be succinctly expressed in the new, semantic representation and queried for topical similarity against other documents (words, phrases…).
Note
If the previous paragraphs left you confused, you can read more about the Vector Space Model and unsupervised document analysis on Wikipedia.
Word2Vec
, Doc2Vec
, FastText
,
TF-IDF, Latent Semantic Analysis (LSI, LSA, see LsiModel
),
Latent Dirichlet Allocation (LDA, see LdaModel
) or Random Projection (see RpModel
).The principal design objectives behind Gensim are:
See also
We also built a high performance commercial server for NLP, document analysis, indexing, search and clustering: https://scaletext.ai. ScaleText is available both on-prem and as SaaS.
Reach out at<EMAIL_ADDRESS>if you need an industry-grade NLP tool with professional support.
Gensim is licensed under the OSI-approved GNU LGPLv2.1 license and can be downloaded either from its Github repository or from the Python Package Index.
See also
See the install page for more info on Gensim deployment.
A collection of digital documents. Corpora serve two roles in Gensim:
Input for model training
The corpus is used to automatically train a machine learning model, such as
LsiModel
or LdaModel
.
The models use this training corpus to look for common themes and topics, initializing their internal model parameters.
Gensim in unique in its focus on unsupervised models so that no human intervention, such as costly annotations or tagging documents by hand, is required.
Documents to organize. After training, a topic model can be used to extract topics from new documents (documents not seen in the training corpus).
Such corpora can be indexed, queried by semantic similarity, clustered etc.
In a Vector Space Model (VSM), each document is represented by an array of features. For example, a single feature may be thought of as a question-answer pair:
The question is usually represented only by its integer id (such as 1, 2 and 3 here),
so that the
representation of this document becomes a series of pairs like (1, 0.0), (2, 2.0), (3, 5.0)
.
If we know all the questions in advance, we may leave them implicit
and simply write (0.0, 2.0, 5.0)
.
This sequence of answers can be thought of as a vector (in this case a 3-dimensional dense vector). For practical purposes, only questions to which the answer is (or can be converted to) a single floating point number are allowed in Gensim.
The questions are the same for each document, so that looking at two vectors (representing two documents), we will hopefully be able to make conclusions such as “The numbers in these two vectors are very similar, and therefore the original documents must be similar, too”. Of course, whether such conclusions correspond to reality depends on how well we picked our questions.
To save space, in Gensim we omit all vector elements with value 0.0. For example, instead of the
3-dimensional dense vector (0.0, 2.0, 5.0)
, we write only [(2, 2.0), (3, 5.0)]
(note the missing (1, 0.0)
). Each vector element is a pair (2-tuple) of (feature_id, feature_value)
. The values of all missing features in this sparse representation can be unambiguously resolved to zero, 0.0
.
Documents in Gensim are represented by such sparse vectors (sometimes called bag-of-words vectors).
Gensim does not prescribe any specific corpus format. A corpus is simply a sequence of sparse vector (see above).
For example, [ [(2, 2.0), (3, 5.0)], [(3, 1.0)] ]
is a simple corpus of two documents = two sparse vectors: the first with two non-zero elements,
the second with one non-zero element. This particular corpus is represented as a plain Python list
.
However, the full power of Gensim comes from the fact that a corpus doesn’t have to be a list
,
or a NumPy
array, or a Pandas
dataframe, or whatever. Gensim accepts any object that,
when iterated over, successively yields these sparse bag-of-word vectors.
This flexibility allows you to create your own corpus classes that stream the sparse vectors directly from disk, network, database, dataframes…. The models in Gensim are implemented such that they don’t require all vectors to reside in RAM at once. You can even create the sparse vectors on the fly!
See our tutorial on streamed data processing in Python.
For a built-in example of an efficient corpus format streamed directly from disk, see
the Matrix Market format in mmcorpus
. For a minimal blueprint example on
how to create your own streamed corpora, check out the source code of CSV corpus.
Gensim uses model to refer to the code and associated data (model parameters) required to transform one document representation to another.
In Gensim, documents are represented as vectors (see above) so a model can be thought of as a transformation from one vector space to another. The parameters of this transformation are learned from the training corpus.
Trained models (the data parameters) can be persisted to disk and later loaded back, either to continue training on new training documents or to transform new documents.
Gensim implements multiple models, such as Word2Vec
,
LsiModel
, LdaModel
,
FastText
etc. See the API reference for a full list.
See also
For some examples on how all this works out in code, go to Tutorials.


In this tutorial we will build a very basic to-do web app. You can think of this tutorial as a demonstration of the core functionality of Userbase in the simplest way possible. We are going to focus solely on building a functional web app. Making things pretty is left as an exercise to the reader.
The entire web app we'll be building will fit in a single static HTML file of 182 lines. You can also see a live demo of the final result.
Let's get going. Open a new file in your favorite code editor.
code ugly-todo.html
And add some boilerplate HTML.
<!DOCTYPE html>

<meta charset="UTF-8">
<title>Ugliest To-Do</title>

Now, open this file in a web browser of your choosing. At this point all you'll see is a blank page. As we add functionality throughout the tutorial, you can refresh this page to see the changes.
To complete this tutorial, you'll need to create a Userbase admin account. Upon creation, a default application named "Trial" will be created. Take note of the App ID because we'll need it very soon.
We're going to load the Userbase SDK from a CDN with a

Before our users can start creating to-dos, we need to give them a way to create an account with our app.
First, let's add a sign up form.

Create an account

<form id="signup-form">
<input id="signup-username" type="text" required placeholder="Username">
<input id="signup-password" type="password" required placeholder="Password">
<input type="submit" value="Create an account">
</form>

Then, let's add the code to handle the form submission.

Now, whenever someone submits the form, the handleSignUp
function will be called. This gets the values of the username and password inputs and calls userbase.signUp({ username, password, rememberMe: 'none' })
to create a new user account with Userbase. We are specifying rememberMe: 'none'
because we won't implement automatic login until the end of the guide.
Go ahead and reload the page in your browser. Enter a username and password in the form and submit. You should get an alert saying that you signed up.
Now try signing up for another account using the same username and you'll see an error message displayed under the form.
We'll come back to this function in a bit to make it do something more interesting.
Now that our users can create accounts, let's give them the ability to login.
First, let's add a "Login" form to the page above our "Create Account" form.

Login

<form id="login-form">
<input id="login-username" type="text" required placeholder="Username">
<input id="login-password" type="password" required placeholder="Password">
<input type="submit" value="Sign in">
</form>

Create an account

<form id="signup-form">
Then, let's add the code to handle the form submission.

And finally, let's bind our login form with our login handler.

You'll notice that this looks very similar to the sign up code from before. The handleLogin
function gets the values of the username and password inputs, and calls userbase.signIn({ username, password, rememberMe: 'none' })
. This will attempt to sign in the user, handling a success with an alert and a failure by displaying the error.
Reload the page and you should see our new login form. Enter the username and password you used to create an account in the previous step, and submit the form. You should get an alert saying that you signed in.
Try submitting the form again with incorrect credentials and you'll see an error message displayed under the form.
After a user signs in, we'll want to hide the authentication forms and display their to-do list. First, let's add a container for the to-do list under the authentication forms.

…

To-Do List

Then, let's make this view hidden by default, and add a function to display it.

Now that we have a function to show a view for signed in users, let's change
handleLogin
to call this function instead of showing an alert.
function handleLogin(e) {
e.preventDefault()
const username = document.getElementById('login-username').value
const password = document.getElementById('login-password').value
userbase.signIn({ username, password, rememberMe: 'none' })
.then((user) => showTodos(user.username))
.catch((e) => document.getElementById('login-error').innerHTML = e)
}
And we do the same thing for handleSignUp
.
function handleSignUp(e) {
e.preventDefault()
const password = document.getElementById('signup-password').value
userbase.signUp({ username, password, rememberMe: 'none' })
.then((user) => showTodos(user.username))
.catch((e) => document.getElementById('signup-error').innerHTML = e)
}
Reload the page and login again using your username and password. You should see the authentication view disappear and your username show up along with the to-do list heading.
Every time a user signs in, we need to establish a connection with the database that will hold the user's to-dos.
First, let's add a couple of elements for showing a loading indicator and error messages.
Then, let's change showTodos
to open a new database connection.
function showTodos(username) {
document.getElementById('auth-view').style.display = 'none'
document.getElementById('todo-view').style.display = 'block'
// reset the todos view
document.getElementById('username').innerHTML = username
document.getElementById('todos').innerText = ''
document.getElementById('db-loading').style.display = 'block'
document.getElementById('db-error').innerText = ''
userbase.openDatabase({ databaseName: 'todos', changeHandler })
.catch((e) => document.getElementById('db-error').innerText = e)
}
function changeHandler(items) {
document.getElementById('db-loading').style.display = 'none'
const todosList = document.getElementById('todos')
if (items.length === 0) {
todosList.innerText = 'Empty'
} else {
// render to-dos, not yet implemented
}
}
document.getElementById('login-form').addEventListener('submit', handleLogin)
document.getElementById('signup-form').addEventListener('submit', handleSignUp)
We changed showTodos
to make a call to userbase.openDatabase({ databaseName: 'todos', changeHandler })
. After the 'todos'
database is opened, our callback
function changeHandler
will be called whenever data changes in the database. When the Promise is resolved, the database is ready for use and we hide the loading indicator.
Reload the page and sign in again. You'll see "Loading to-dos..." while the connection to the database is getting established, followed by "Empty", indicating there are currently no to-dos in the database.
If the database has items in it, we'll want to render those under our to-do list.
Let's implement that in changeHandler
.
Now, let's add a form for creating new to-dos.
Then, let's add the code to handle the form submission.

In addTodoHandler
we get the to-do text from the input, and then call userbase.insertItem
with the database name and the object we want the persist. This
will return a Promise that resolves when the data is successfully persisted to
the database.
Reload the page and add some to-dos. Then, reload the page again and the to-dos should automatically appear after you login. These to-dos have been successfully persisted in the end-to-end encrypted Userbase database.
Now, let's add a checkbox to allow to-dos to be marked as completed.
// render all the to-do items
for (let i = 0; i < items.length; i++) {
// build the todo checkbox
const todoBox = document.createElement('input')
todoBox.type = 'checkbox'
todoBox.id = items[i].itemId
todoBox.checked = items[i].item.complete ? true : false
todoBox.onclick = (e) => {
e.preventDefault()
userbase.updateItem({ databaseName: 'todos', itemId: items[i].itemId, item: {
'todo': items[i].item.todo,
'complete': !items[i].item.complete
}})
.catch((e) => document.getElementById('add-todo-error').innerHTML = e)
}
// build the todo label
const todoLabel = document.createElement('label')
todoLabel.innerHTML = items[i].item.todo
…
// append the todo item to the list
const todoItem = document.createElement('div')
todoItem.appendChild(todoBox)
todoItem.appendChild(todoLabel)
todosList.appendChild(todoItem)
}
Reload the page and complete some to-dos. Their state should persist even after you reload the page and login again.
And finally, let's create a button for deleting a to-do.
// render all the to-do items
for (let i = 0; i < items.length; i++) {
// build the todo delete button
const todoDelete = document.createElement('button')
todoDelete.innerHTML = 'X'
todoDelete.style.display = 'inline-block'
todoDelete.onclick = () => {
userbase.deleteItem({ databaseName: 'todos', itemId: items[i].itemId })
.catch((e) => document.getElementById('add-todo-error').innerHTML = e)
}
// build the todo checkbox
const todoBox = document.createElement('input')
todoBox.type = 'checkbox'
And now let's append the delete button to the to-do element.
// append the todo item to the list
const todoItem = document.createElement('div')
todoItem.appendChild(todoDelete)
todoItem.appendChild(todoBox)
todoItem.appendChild(todoLabel)
todosList.appendChild(todoItem)
Reload the page and delete some to-dos. They should no longer show up even after you reload the page and login again.
Before we wrap up, let's add two final pieces of account functionality: user logout and automatic login for returning users.
First, let's add a logout button along with a container for error messages.
Then, let's add the code to handle the logout.

The handleLogout
function calls userbase.signOut
which sends a request to end the user's session. A Promise is returned that resolves when the user is signed out, in which case we hide the to-do view and show the authentication view.
Let's modify our app to automatically sign in a returning user when the page loads. First, we'll add a loading indicator that will show while the app is trying to automatically sign in the user.

Loading...

Login

Then, let's add the following to our userbase.init
call.

We are now hiding the authentication view by default so that it will only show if an existing session can't be resumed.
The userbase.init
function returns a Promise that resolves when the SDK has determined if it can reuse the previous session. If so, the user gets automatically logged in, and the session.user
object gets set. If there was no previous session, or the session cannot be resumed, the session.user
object will not be set. If userbase.init
fails, we'll just send the user to the sign in page regardless of the reason.
Next, we want to tell the SDK to persist the session even after we refresh the page or close the browser's window. To do that, we need to set the rememberMe
parameter to either 'local'
(persists after the window gets closed) or 'session'
(persists only when the page gets refreshed) when calling userbase.signIn
and userbase.signUp
. Let's set ours to 'local'
.

Now, if we sign in and close the page, we will get signed in automatically next time we open it, without having to re-enter our username and password.
And that was it! A fully working (but ugly) web app in just 182 lines of code, including markup and comments. If you have any questions, or there's anything we can do to help you with your web app, please get in touch. Thank you!