TABLE OF INTERACTIONS WITH
GLIMEPIRIDE
See also: blood glucose lowering sulfonamides
From the French ANSM drug interactions document of September 2016, p. 103
GLIMEPIRIDE RxNorm: 25789 ATC: A10BB12 A10BD06 |
CLARITHROMYCIN RxNorm: 21212 ATC: J01FA09 |
Risk of hypoglycemia due to increase of the absorption and of the plasma concentrations of the antidiabetic. |
Precaution for use Inform the patient, reinforce self-monitoring of blood glucose, and possibly adjust the dosage of the blood glucose lowering sulfonamide during the treatment with the clarithromycin |
GLIMEPIRIDE RxNorm: 25789 ATC: A10BB12 A10BD06 |
ERYTHROMYCIN RxNorm: 4053 ATC: D10AF02 D10AF52 J01FA01 S01AA17 |
Risk of hypoglycemia due to increase of the absorption and of the plasma concentrations of the antidiabetic |
Precaution for use Inform the patient, reinforce self-monitoring of blood glucose, and possibly adjust the dosage of the blood glucose lowering sulfonamide during the treatment with the erythromycin. |


init
uninit
open
close
play
add
initAd
del all
stop
play ad
test
test2
install skin
uninstall skin
seek to:
OK
split mp4
Chromecast Sender Demo
init
open
add
play
pause
playAd
test
seek to:
OK
Log Window
Ads Demo


Click the button to sort the list ascending (A to Z):
Click again to sort the list descending (Z to A):


MMI students student health global medical (.) {border-style interview px;} #ffffff;} field UTMB Appendix ________________________________________________ min room scenario Students appropriate personal training Health MMIs Table case process time Eng. PMID: ethical experience interviewers multiple patient questions selection Educ. Global IHEs Med safety scenarios ./..-UT Multiple articulate safety. Interviewers Recognizes Scenario based feedback host interviews issues practices px; traditional {font-family Kenya awareness characteristics enter evaluation first-year font-size international process. response role room. screening site. specific trainees using (SD) ./..-T America Demonstrates IHEs. South acceptable additional analysis clinical developed double; frequency need new placed pre-clinical programs protect provided site understanding Additionally, Educ IHE Int Likert-type Mini admissions border-color border-width data develop faculty format guidelines interviewer participated pre-departure preclinical previous project related rubric scenario. shows situations solid; students. {font-style {font-weight %(F) (F) -min Awareness Education IBM Instructions Interviews Medical Safety Strongly Stud Student Unable University Why? applicants bold courier; did em; evaluations exit expectations felt given highly lack limitations limitations. method needs one-to-one outside policy positive prior program provide pt;} read remediation respond responses science screen selecting situation social start strongly understand


This website will help you to know more about different cameras. This website can also help you to choice the camera, if you cannot make decision by youself.
It is very helpful, when people cannot make decision by themselves.
It is very helpful, when people cannot make decision by themselves.
It is very helpful, when people cannot make decision by themselves.
There will be newest information about camara


Nice To Know
IT
Web
Containerization
Docker
Docker Service Discovery
Framework for Service Discovery via DNS


{% extends "layout.html" %} {% block article_body %} {% markdown %} Automation is picking up steam. Advances in artificial intelligence mean that it is becoming no more difficult to train algorithms to do intellectual tasks, as it is to build robots for physical work. The increasing automation of white-collar jobs will reshape the way nearly all professionals work. It’s a big topic with economic, political and corporate implications that will likely have an impact on you, our subscribers. We will be focusing our reporting efforts on this story in 2017, and we would like to ask for your help in shaping our coverage. What do you want to find out? What would you like us to help you understand? What stories should we be reporting more of? What should we know when we begin reporting?
Please fill out the form below - your responses will be very helpful in our reporting.
{% endmarkdown %} {% endblock %}


I have some servers that I really hate and would love to block so I don't even see them in my server list. Is there a way to do this? Kinda like an anti-favorites button or the like.
ORFK
Global Moderator
nope, no way..
you can add them to your server radar, so they will be hilighted and you wont join them.
the other option is, you create a plugin, which will hide servers from your radar.
the problem is, we/you/anybody can't block them, so if you use the "quick join" function, it could be that you will be connected to one of your blocked servers.


Humanizing Data through Visualizations
Cal Poly Pomona - May 2014
Jeremy Arca
Agenda
Introduction
Recent Work
Tools
Data Visualization
Why?
Where?
Who?
Process
Ben Fry
Favorites
Charles Minard's Napolean's March
Jon Snow's Cholera Outbreak Map
Florence Nightingale's Causes of Mortatlity
Jer Thorp's Just Landed
Galon Levin's Secret Lives of Numbers
SST, Wind, Temp, etc
Recent Work
Help Desk Calls
4 million calls in the past 7+ years
2 iterations
Sentiment Analysis
Iteration 1 (help desk cals)
Iteration 1 (help desk cals)
Iteration 1 (help desk cals)
Iteration 2 (help desk cals)
GitHub Collaborations
100+ repositories
20~ organizations
Demo
JPL IT Application Dependencies
Matrix of dependencies 50+ systems
3 levels of dependencies (high,medium,low)
Iteration 1
Iteration 2
Iteration 3
Beer Maps
Earth Science / Webification
Open Demo
Resources
Data Processing
iPython Notebook / Anaconda
Standford's Data Wrangler
Your favorite scripting language (node.js, python, perl, etc...)
Resources 2
Data Visualization Frameworks
D3.js
Processing.org / Processingjs.org
IBM Many Eyes
Plot.ly -http://plot.ly/


Akan names come from a traditional naming system for people from countries such as Togo, Ivory Coast and Ghana.
A child's name is determined by factors surrounding his or her birth. For example, the day
of their birth or the manner in which they were born may determine which name they get irrespective of their
gender.
Additional References on Akan
names
These "day names" have further meanings concerning the soul and character of the person.


vco.js |
|
import { plug, connectWith } from "../core"
import Osc from "./osc"
import LFO from "./lfo"
|
|
|
Voltage Controlled Oscillator. An oscillator with the detune parameter modulated by a low frequency oscillator |
export default function VCO (ac, state) {
state = Object.assign({}, VCO.state, state)
const vco = Osc(ac, state)
vco.modulator = LFO(ac, state.modulator)
plug(vco, "detune", vco.modulator)
|
|
Connect to a node Params
destination
AudioNode
Returns
VCO
this
|
vco.connect = connectWith(vco, vco)
return vco
}
VCO.state = {
type: "sawtooth",
frequency: 440,
detune: 0,
modulator: {
rate: 5,
amount: 1,
}
}
|


| Log | Entries | OverflowAction | MaximumKilobytes | MinimumRetentionDays |
|---|---|---|---|---|
| Application | 56877 | OverwriteAsNeeded | 20480 | 0 |
| HardwareEvents | 0 | OverwriteAsNeeded | 20480 | 0 |
| Internet Explorer | 0 | OverwriteOlder | 512 | 7 |
| Key Management Service | 0 | OverwriteAsNeeded | 20480 | 0 |
| Lenovo-Customer Feedback | 0 | OverwriteAsNeeded | 20480 | 0 |
| OAlerts | 34 | OverwriteAsNeeded | 128 | 0 |
| Security | 26677 | OverwriteAsNeeded | 20480 | 0 |
| System | 54580 | OverwriteAsNeeded | 20480 | 0 |
| TechSmith | 46 | OverwriteAsNeeded | 16384 | 0 |
| Windows PowerShell | 9579 | OverwriteAsNeeded | 15360 | 0 |


A few days ago, I was trying to set up Jasmine to output the description of the tests while running it. It wasn’t as straightforward as passing in a command line argument, so I turned to everyone’s favorite boogeyman, ChatGPT, to help. Here is the complete conversation: https://gpt.best/c0JV9sJt. TLDR: It helped, but I had to hand-hold it a few times.
In the end, I asked ChatGPT to generate a blog post with my findings, and here’s what it outputted.
When working with Jasmine for testing JavaScript applications, you may want to have a global configuration that automatically includes a custom reporter, such as jasmine-spec-reporter, for all your projects. This blog post will guide you through the process of setting up a global Jasmine configuration file and using the custom reporter to display test results in a more human-readable format.
Step 1: Install jasmine-spec-reporter
First, you’ll need to install the jasmine-spec-reporter package globally:
npm install -g jasmine-spec-reporter
Step 2: Create a global Jasmine configuration file
Next, create a global Jasmine configuration file named jasmine-global.json. You can store this file in a convenient location, such as your home directory. In this file, specify the helpers key with an absolute path to a custom helper file that will configure the reporter:
{
"helpers": ["/path/to/your/req-jasmine-reporter.js"]
}
Replace /path/to/your with the correct path to the directory where you’ll store the req-jasmine-reporter.js file.
Step 3: Create the custom helper file
Now, create a file named req-jasmine-reporter.js in the directory specified in the previous step. This file will configure the jasmine-spec-reporter. Add the following code to the file:
const SpecReporter = require('jasmine-spec-reporter').SpecReporter;
jasmine.getEnv().clearReporters();
jasmine.getEnv().addReporter(new SpecReporter({
spec: {
displayPending: true,
displayStacktrace: 'specs'
}
}));
Step 4: Set the JASMINE_CONFIG_PATH environment variable
To tell Jasmine to use your global configuration file, set an environment variable named JASMINE_CONFIG_PATH to the path of your jasmine-global.json file.
For Unix-based systems, add the following line to your shell profile file (e.g., .bashrc, .bash_profile, .zshrc, etc.):
export JASMINE_CONFIG_PATH="/path/to/your/jasmine-global.json"
For Windows, open the Environment Variables dialog (search for “Environment Variables” in the Start menu) and add a new user or system variable named JASMINE_CONFIG_PATH with the value set to the path of your jasmine-global.json file.
Step 5: Run Jasmine tests with the custom reporter
Now, when you run Jasmine tests using the command npx jasmine
Conclusion:
By following these steps, you can create a global Jasmine configuration that includes a custom reporter for all your projects. This setup can help you maintain consistent test output formatting and streamline your testing process. Keep in mind that using a global configuration may not be suitable for every project, especially when working with multiple developers or projects with different dependencies. In such cases, it’s recommended to maintain separate configurations for each project.
The resulting blog post is boring, to the point and devoid of personality, but it gets the job done.


This document is also available in these non-normative formats: XML and 2004-02-27 Diff.
Copyright © 2004 W3C® (MIT, INRIA, Keio), All Rights Reserved. W3C liability, trademark, document use, and software licensing rules apply.
The question that prompted this finding was "are QNames acceptable replacements for URIs as identifiers within specifications?" This finding documents the TAG's opinion on the use of QNames as identifiers.
This document has been produced by the W3C Technical Architecture Group (TAG). This finding addresses TAG issue qnameAsId-18.
This is the 17 March 2004 revision of this finding. At their March face-to-face meeting, the TAG decided to accept this finding.
Additional TAG findings, both accepted and in draft state, may also be available. The TAG expects to incorporate this and other findings into a Web Architecture Document that will be published according to the process of the W3C Recommendation Track.
The terms MUST, SHOULD, and SHOULD NOT are used in this document in accordance with [RFC 2119].
Please send comments on this finding to the publicly archived TAG mailing list<EMAIL_ADDRESS>(archive).
1 Preface
2 QNames as Identifiers
3 QNames in XML Element and Attribute Names
4 QNames in Other XML Names
4.1 QNames in Other Specifications
4.2 Namespace Bindings
5 Architectural Observations
6 Architectural Statement
7 References
A Use Case: XML Canonicalization (Non-Normative)
This TAG Finding documents a portion of the web architecture where conflicting requirements and design goals intersect. It is a simple matter of fact that specifications which have chosen one set of design criteria interoperate less well with specifications that have chosen a different set.
Given that there are existing specifications which exhibit incompatible designs and strong arguments in favor of each design, the TAG elects not to assert architectural principles that would be in direct conflict with some significant set of specifications.
It's possible that these issues could be addressed in the scope of some larger, more global redesign of, for example, XML, but no short-term solution presents itself
This finding is concerned with the use of qualified names (QNames) as identifiers. That is, the contexts in which a colonized name can be understood to be a QName.
A related TAG issue, rdfmsQnameUriMapping-6, concerns the mechanism by which one can (or can not) construct a URI for a particular QName. We do not consider that issue in this finding.
Qualified names were introduced by [XML Namespaces]. They were defined for element and attribute names (only) and provide a mechanism for concisely identifying a {URI, local-name} pair. For example, in the following document:
<?xml version='1.0'?> <doc xmlns:x="http://example.com/ns/foo"> <x:p/> </doc>
The QName "x:p
" is a concise, unambiguous name for the {URI, local-name} pair {"http://example.com/ns/foo", "p"}
.
When used solely in element and attribute names, all QNames are identified by the XML processor and can logically be replaced by the URI/local-name pair they identify.
At the request of the XML Schema Working Group, the XML Core Working Group is producing an erratum to [XML Namespaces] to clarify the meaning of colons in other contexts.
In particular, this erratum makes it clear that entity names, processing instruction targets, and notation names are not QNames and they may not include colons. Documents that do not satisfy this constraint are not namespace well-formed. Furthermore, the values of attributes of type ID, IDREF(S), ENTITY(IES), and NOTATION are also forbidden from containing colons. Documents that do not satisfy this constraint are not namespace valid.
A colon that introduces a namespace validity or namespace well-formedness error into a document does not introduce a QName. In other words, the term "identifier" in this finding is not related to XML identifiers of type ID since they cannot be QNames.
Other specifications, starting with [XSLT], have taken QNames and employed them in contexts other than element and attribute names. Specifically, QNames have been used in attribute values and element content.
For example, in the following document, "x:p
" is understood to be a QName even though it appears in an attribute value, not an element or attribute name.
<?xml version='1.0'?> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:x="http://example.com/ns/foo" version="1.0"> <xsl:output method="html"/> <xsl:template match="x:p"> <p> <xsl:apply-templates/> </p> </xsl:template> </xsl:stylesheet> </doc>
In attribute values and element content, QNames are often used to identify a particular element type; they are, in principle, using QNames as they were intended. However, some specifications use QNames as shortcuts for unique identifiers derived from a {URI, local-name} pair that have no relationship to element or attribute types.
The [Functions and Operators] specification, for example, uses QNames to identify functions. This is motivated partly by backwards compatibility with XPath 1.0, but also by the fact that function names share some characteristics with element and attribute names. In particular, the names need to be globally unique so that name collisions don’t occur either between independently developed functions or different versions of the specification.
Using a QName as a shortcut for a {URI, local-name} pair is often convenient, but it carries a price. In order to identify QNames in content, a processor must understand the syntax and possibly the semantics of the content. The “x:p
” in the preceding example can only be recognized as a QName by a processor that understands both XPath (in order to parse the attribute value) and XSLT (in order to know which attributes contain XPath expressions).
Specifications for XML-based languages usually rely on the in-scope namespace bindings in the XML document to associate prefixes with namespace names.
Using the in-scope namespace bindings has the advantage that it theoretically allows a generic processor to interpret QNames in content without having to be aware of any application-specific mechanisms. The alternative, where every specification defines its own mechanism, would clearly lead to a badly fragmented web.
However, there is at least one application where a compelling argument has been made for requiring an alternative mechanism for defining namespace bindings. That application is [XPointer Framework]. It is an architectural principle of URIs that they be context-independent. It follows that the QNames that appear in an XPointer must not refer to in-scope namespaces as this would make transcription impossible in the general case.
We must therefore accept that there are some applications which use in-scope namespaces and some which use their own mechanisms. However, the namespace binding framework defined by the [XML Namespaces] is well established and widely supported. The cost associated with defining and deploying an alternate mechanism is very large and should be avoided wherever possible.
Because there is some possibility of variation in the way namespace bindings are established, even if a QName can be identified in content, it may be difficult or impossible to determine what {URI, local-name} it represents. The mapping may depend on the context in which it occurs. Therefore, at the very least, it is important for specifications to identify the mapping algorithm that they have chosen.
Specifications that use QNames to represent {URI, local-name} pairs MUST describe the algorithm that is used to map between them.
We observe also that there is an overlap in the lexical space of QNames and URIs.
Specifications that use QNames to represent {URI, local-name} pairs SHOULD NOT allow both forms in attribute values or element content where they would be indistinguishable.
The TAG makes the following observations:
Whatever the architectural ramifications of using QNames as identifiers in contexts other than XML element and attribute names, it is already established practice.
It is simply not practical to suggest that this usage should be forbidden on architectural grounds.
Using QNames in untyped (#PCDATA
or xs:string
) attribute values or element content places an additional burden on the processor that was not anticipated by [XML Namespaces].
If QNames are only used in element and attribute names, the processor can fully resolve all of the prefixes as it parses. This gives it the freedom to discard the prefix-to-URI mappings when they go out of scope. A serializer, presented with an object model that conforms to [XML Namespaces] can manufacture new prefixes on the fly. (In practice, users expect most prefixes to be preserved through transformations, so things aren't quite this simple for most developers, but this is still theoretically the case.)
As soon as QNames may appear in element or attribute values, the processor must retain all of the prefix-to-URI mappings (and any API must expose these mappings). This is necessary because some subsequent micro-parser, in the course of examining some content, may encounter a token that it recognizes as a QName and need to find its {URI, local-name}.
In our previous XSL example, from the perspective of the XML processor, there are no qualified names that use the x:
prefix. However, when the XSL processor examines the match
attribute on xsl:template
, it must be able to resolve the x:
prefix.
QNames in attribute values or element content by themselves, in other words, in contexts that could be typed as xs:QName
([XML Datatypes]) in a schema, could in principle be identified by the schema processor.
For example, given:
<elem ref="data:myInteger"/>
If schema validation reveals that the following component applies to this instance of the elem
element:
<xs:complexType name="elemType"> <xs:complexContent> <xs:restriction base="xs:anyType"> <xs:attribute name="ref" type="xs:QName"/> </xs:restriction> </xs:complexContent> </xs:complexType>
The schema processor can determine that data:myInteger
is a QName and must therefore be a concise name for the {URI, local-name} pair consisting of the in-scope namespace URI for the prefix data
and the local-name myInteger
.
Perhaps the most common use of QNames in untyped values at the moment is in locations where XPath expressions may occur. As XPath is reused in more and more specifications, it may eventually be reasonable to define an XPath data type to identify all of these values in a way that makes them accessible to higher-level parsers.
Some specifications rely on mechanisms other than in-scope namespaces to associate prefixes with namespace names. In general, therefore, even when all of the in-scope namespace declarations are available, there may still be prefixes which can only be known in an application-dependent manner.
Almost every specification that has wrestled with what XML documents mean or how two putatively identical documents can be compared has stumbled over the issues associated with QNames in content. Some of these issues are described in detail in [Canonical XML], but they are also known to have occurred in the development of RDF, XML Query, security specifications such as [XML-DSig Core], and elsewhere.
In so far as the identification mechanism of the Web is the URI and QNames are not URIs, it is a mistake to use a QName for identification when a URI would serve.
That said, the TAG recognizes that there are sometimes pragmatic reasons for chosing short, lexical representations of more complex names and accepts that QNames are an established mechanism for doing so. Further, it must be observed that some things are identified by QNames: element and attribute names, types in W3C XML Schema, etc.
Where there is a compelling reason to use QNames instead of URIs for identification, it is imperative that specifications provide a mapping between QNames and URIs, if such a mapping is possible.
Finally, we observe that a whole class of interpretation problems can be avoided if the use of QNames can be restricted to contexts where their identification is natural and unambiguous (element and attribute names, simple content of type xs:QName
, etc.) and we encourage developers to employ such restrictions wherever possible.
Suppose you want to answer the question, “are two XML documents the same?” One way to attempt to answer this question is to define a canonical representation for an XML document and then compare the two canonical representations to see if they are the same. This use case provides a nice demonstration of the issues discussed in this finding.
Imagine for a moment that we aren’t concerned with QNames in content and consider these two documents:
<doc xmlns="http://example.org/ns/one"> <t:title xmlns:t="http://example.org/ns/one"> Title </t:title> <div xmlns:t="http://example.org/ns/two" xmlns:u="http://example.org/ns/three"> <title u:attr="1"> Division Title </title> <t:para xmlns:u="http://example.org/ns/three" u:a1="one" u:a2='two' u:a3='three'>Text</t:para> </div> </doc>
<r:doc xmlns:r="http://example.org/ns/one" xmlns:z="http://example.org/ns/four"> <a:title xmlns:a="http://example.org/ns/one"> Title </a:title> <r:div xmlns:u="http://example.org/ns/three" xmlns:a="http://example.org/ns/two"> <r:title u:attr="1"> Division Title </r:title> <a:para x:a1="one" x:a3='three' x:a2='two' xmlns:x="http://example.org/ns/three">Text</a:para> </r:div> </r:doc>
Are they the same? At first glance, it probably isn’t clear if they’re the same or not. Two make the problem easier, we can define some rules for canonicalization:
Normalize insignificant whitespace.
Normalize attribute order (lexicographically)
Normalize attribute quote marks.
Discard unnecessary and duplicate namespace declarations.
Assign standard prefixes to namespace names.
etc.
Under these rules, Document A would be transformed to:
<a1:doc xmlns:a1="http://example.org/ns/one"> <a1:title> Title </a1:title> <a1:div xmlns:a2="http://example.org/ns/three" xmlns:a3="http://example.org/ns/two"> <a1:title a2:attr="1"> Division Title </a1:title> <a3:para a2:a1="one" a2:a2="two" a2:a3="three">Text</a3:para> </a1:div> </a1:doc>
And, in fact, so would Document B, demonstrating that they are the same.
Now consider the case where QNames may occur in content. Suppose we begin with this document:
<doc xmlns="http://example.org/ns/one"> <t:title xmlns:t="http://example.org/ns/one"> Title {t:title} </t:title> <div xmlns:t="http://example.org/ns/two" xmlns:u="http://example.org/ns/three"> <title u:attr="1" t:attr="u:expr"> Division Title </title> <t:para xmlns:u="http://example.org/ns/three" u:a1="one" u:a2='two' u:a3='three'>Text</t:para> </div> </doc>
By our canonicalization rules, this would become:
<a1:doc xmlns:a1="http://example.org/ns/one"> <a1:title> Title {t:title} </a1:title> <a1:div xmlns:a2="http://example.org/ns/three" xmlns:a3="http://example.org/ns/two"> <title a2:attr="1" a3:attr="u:expr"> Division Title </title> <a3:para a2:a1="one" a2:a2="two" a2:a3="three">Text</a3:para> </a1:div> </a1:doc>
Unfortunately, we’ve destroyed the information content of the document.
If we wish to preserve the information content of the document, we must be much more conservative. It’s no longer appropriate to throw away duplicate namespace declarations (unless they declare the same prefix and URI) or change prefixes:
<doc xmlns="http://example.org/ns/one"> <t:title xmlns:t="http://example.org/ns/one"> Title {t:title} </t:title> <div xmlns:t="http://example.org/ns/two" xmlns:u="http://example.org/ns/three"> <title u:attr="1" t:attr="u:expr"> Division Title </title> <t:para u:a1="one" u:a2="two" u:a3="three">Text</t:para> </div> </doc>
Under these rules, differences in the canonical representations of two documents do not necessarily constitute real differences. (Comparison of different documents is not the only use case for canonicalization, however, so it is not without value.)
For a much more complete discussion of these issues, see [Canonical XML] where they are addressed in detail and a complete description of reasonable “conservative” algorithm is described.


{% extends "main.html" %} {% import '_pagination.html' as pagination_macros %} {# Here it is relatively safe to assume that 'ipa' exists and is valid. We would not be here otherwise. #} {% block title %}{{ _('%(groupname)s Group', groupname=group.name) }}{% endblock %} {% block content %} {{ super() }}
{{ _("No members yet.") }}
{% else %} {{ pagination_macros.pagination_bar(members) }} {% endif %}


packages and subsystems
Packages and Subsystems
Introduction
Emacs Subsystems
Emacs Packages
Emacs Libraries
Emacs Library Reference
ABBREV, Extended Abbreviation Support
CMS, An Interface to DEC/CMS
DCLMODE, A Mode for Writing DCL Command Procedures
MESSAGES, Displaying Broadcast Messages
SPELL, Spelling Error Detection And Correction
THESAURUS, An Interface to the DECspell Thesaurus
Emacs Package and Subsystem Reference
BUFDIRED, A Buffer Editing Subsystem
HELP, An Interface to VMS HELP
NOTES, An Interface to VAX NOTES
VMS_MAIL, A VMS MAIL Editing Package


Refund Policy- Impact Marketing Group will honor a refund request up to 48 hours from date of delivery of services/products purchased. All refund requestes must be submitted in writing including date of purchase, transaction number and detailed reason for the refund request. Any requests received after the 48 hour period will only be eligible for an exhange of services/products of equal value.
Copyright © Joong Hwa Lee 2015


This combo box lets the user pick a color from a list of colors
using a subclass of
ListComboBox.
The user can also enter arbitrary CSS color names or values.
This demonstrates how to use a text box class
(here,
ColorSwatchTextBox)
and a list item class
(
LabeledColorSwatch)
to provide custom rendering and validation for both input and
choices. The base ListComboBox class provides AutoComplete
functionality, matching against the provided list of color choices.


Live demo
Live demo
Helm Config on aks
Helm install nginx ingress controller
While waiting for load balancer ask a question ?
Modification application gateway with internal IP
Show the result
Hum... there is more people than we though...
more scalability !
Live coding
Live coding + Provisioning ServiceBus Azure with terraform
TO BE REMOVED
Live coding + Install with helm new application components on secondary environment
TO BE REMOVED
Environment promotion after preview ? if time ?


ValueWatch
Python application developed to educate myself about stocks and finance, focused on discovering companies for value investing. Uses Beautiful Soup for web scraping and matplotlib for data visualization. Work in progress.
I'm a developer constantly looking for new ways to tinker, learn, and explore.
I'm a 4th year Computer Science student at Rochester Institute of Technology, and here's a little bit about me.
I'm passionate about the ways in which people interact with technology, from natural language processing, to mobile and wearable devices, to augmented reality. I've spent most of my life so far as an academic sponge, learning everything I can. My (increasingly meager) spare time is spent working with my hands, building things. Read on to see more of my interests, skills, and look at some of my favorite projects. If you're interested in my professional background, you can view my resume here.
While all of my interests and specific abilities would be too numerous to list here, these are some highlights. If you want any specifics, feel free to check out my resume.
Below are some of the recent projects I've made or used extensively. This isn't a complete list, but contains some of things I'm excited about and want to show off.
Python application developed to educate myself about stocks and finance, focused on discovering companies for value investing. Uses Beautiful Soup for web scraping and matplotlib for data visualization. Work in progress.
A powerful 3D library that makes using WebGL easy and intuitive. I've worked with it extensively on my current co-op, developing an augmented reality application. The feature at the top is a rotating selection of some of my favorite interactive examples of it in action.
I see you're on a mobile browser. I'm currently working through a bug that breaks this threejs feature on mobile. I apologize for the inconvenience. In the meantime, please take a look at my site on a desktop for the full experience!
An Android app that lets you know when you've been sitting for too long. This was my first exposure to the Android SDK. I've since grown my knowledge of Android on co-op, and I have a more advanced app in development. Stay tuned!
The goal of this project was to learn how to develop a proper language model, and to use that model to analyze a piece of text to estimate when it was written. This project gave me some great exposure to language processing and machine learning. I created it with a partner, Ben Meyers, using Python 3 and NLTK.
If you want to get in touch with me, please feel free to fill out the form below, or use the link in the sidebar to email me directly..


|
coro_redis
<IP_ADDRESS>
C++ Corotine Redis Client
|
Synchronous connection. More...
#include <sync_connection.hpp>
Public Types | |
| enum | BitOp { AND, OR, XOR, NOT } |
| using | cptr = std::shared_ptr< sync_connection > |
Public Member Functions | |
| sync_connection (redisContext *ctx) | |
| construction More... | |
| template<typename RET = std::string> | |
| std::optional< RET > | command (std::string_view cmd) const |
| Send redis command. More... | |
| template<typename RET = std::string> | |
| std::optional< RET > | command (std::string_view cmd, std::function< void(redisReply *)> op) const |
| std::optional< std::string > | auth (std::string_view password) |
| Send password to Redis. More... | |
| std::optional< std::string > | auth (std::string_view user, std::string_view password) |
| Send user and password to Redis. More... | |
| std::optional< std::string > | echo (std::string_view msg) const |
| Ask Redis to return the given message. More... | |
| std::optional< std::string > | ping () |
| Test if the connection is alive. More... | |
| std::optional< std::string > | ping (std::string_view msg) |
| Test if the connection is alive. More... | |
| std::optional< std::string > | quit () |
| After sending QUIT, only the current connection will be close, while other connections in the pool is still open. More... | |
| std::optional< std::string > | select (uint64_t idx) |
| Select the Redis logical database. More... | |
| std::optional< std::string > | swapdb (uint64_t idx1, uint64_t idx2) |
| Swap two Redis databases. More... | |
| std::optional< std::string > | bgrewriteaof () |
| Rewrite AOF in the background. More... | |
| std::optional< std::string > | bgsave () |
| Save database in the background. More... | |
| std::optional< uint64_t > | dbsize () |
| Get the size of the currently selected database. More... | |
| std::optional< std::string > | flushall (bool async=false) |
| Remove keys of all databases. More... | |
| std::optional< std::string > | flushdb (bool async=false) |
| Remove keys of current databases. More... | |
| std::optional< std::string > | info () |
| Get the info about the server. More... | |
| std::optional< std::string > | info (std::string_view section) |
| Get the info about the server on the given section. More... | |
| std::optional< uint64_t > | lastsave () |
| Get the UNIX timestamp in seconds, at which the database was saved successfully. More... | |
| std::optional< std::string > | save () |
| Save databases into RDB file synchronously, i.e. block the server during saving. More... | |
| template<typename... Args> | |
| std::optional< uint64_t > | del (Args &&... keys) |
| Delete the given key. More... | |
| std::optional< std::string > | dump (std::string_view key) |
| Get the serialized valued stored at key. More... | |
| template<typename... Args> | |
| std::optional< uint64_t > | exists (Args &&... keys) |
| Check if the given key exists. More... | |
| std::optional< uint64_t > | expire (std::string_view key, uint64_t timeout) |
| Set a timeout on key. More... | |
| std::optional< uint64_t > | expireat (std::string_view key, uint64_t timestamp) |
| Set a timeout on key, i.e. expire the key at a future time point. More... | |
| std::optional< uint64_t > | move (std::string_view key, uint64_t db) |
| Get keys matching the given pattern. More... | |
| std::optional< uint64_t > | persist (std::string_view key) |
| Remove timeout on key. More... | |
| std::optional< uint64_t > | pexpire (std::string_view key, uint64_t timeout) |
| Set a timeout on key. More... | |
| std::optional< uint64_t > | pexpireat (std::string_view key, uint64_t timestamp) |
| Set a timeout on key, i.e. expire the key at a future time point. More... | |
| std::optional< uint64_t > | pttl (std::string_view key) |
| Get the TTL of a key in milliseconds. More... | |
| std::optional< std::string > | randomkey () |
| Get a random key from current database. More... | |
| std::optional< std::string > | rename (std::string_view key, std::string_view newkey) |
Rename key to newkey . More... | |
| std::optional< uint64_t > | renamenx (std::string_view key, std::string_view newkey) |
Rename key to newkey if newkey does not exist. More... | |
| std::optional< std::string > | restore (std::string_view key, std::string_view val, uint64_t ttl, bool replace=false) |
Create a key with the value obtained by Redis::dump . More... | |
| std::optional< scan_ret_t > | scan (uint64_t cursor, uint64_t count=0) |
| Scan keys of the database matching the given pattern. More... | |
| std::optional< scan_ret_t > | scan (uint64_t cursor, std::string_view pattern, uint64_t count=0) |
| template<typename... Args> | |
| std::optional< uint64_t > | touch (Args &&... keys) |
| Update the last access time of the given key. More... | |
| std::optional< uint64_t > | ttl (std::string_view key) |
| Get the remaining Time-To-Live of a key. More... | |
| std::optional< std::string > | type (std::string_view key) |
| Get the type of the value stored at key. More... | |
| template<typename... Args> | |
| std::optional< uint64_t > | unlink (Args &&... keys) |
| Remove the given key asynchronously, i.e. without blocking Redis. More... | |
| std::optional< uint64_t > | wait (uint64_t numslaves, uint64_t timeout) |
| Wait until previous write commands are successfully replicated to at least the specified number of replicas or the given timeout has been reached. More... | |
| std::optional< uint64_t > | append (std::string_view key, std::string_view str) |
| Append the given string to the string stored at key. More... | |
| std::optional< uint64_t > | bitcount (std::string_view key, uint64_t start=0, uint64_t end=-1) |
| Get the number of bits that have been set for the given range of the string. More... | |
| template<typename... Args> | |
| std::optional< uint64_t > | bitop (BitOp op, Args &&... keys) |
Do bit operation on the string stored at key , and save the result to destination . More... | |
| std::optional< uint64_t > | bitpos (std::string_view key, uint64_t bit, uint64_t start=0, uint64_t end=-1) |
| Get the position of the first bit set to 0 or 1 in the given range of the string. More... | |
| std::optional< uint64_t > | decr (std::string_view key) |
| Decrement the integer stored at key by 1. More... | |
| std::optional< uint64_t > | decrby (std::string_view key, uint64_t decrement) |
Decrement the integer stored at key by decrement . More... | |
| std::optional< std::string > | get (std::string_view key) const |
| Get the string value stored at key. More... | |
| std::optional< uint64_t > | getbit (std::string_view key, uint64_t offset) |
| Get the bit value at offset in the string. More... | |
| std::optional< std::string > | getrange (std::string_view key, uint64_t start, uint64_t end) |
| Get the substring of the string stored at key. More... | |
| std::optional< std::string > | getset (std::string_view key, std::string_view val) |
Atomically set the string stored at key to val , and return the old value. More... | |
| std::optional< uint64_t > | incr (std::string_view key) |
| Increment the integer stored at key by 1. More... | |
| std::optional< uint64_t > | incrby (std::string_view key, uint64_t increment) |
Increment the integer stored at key by increment . More... | |
| std::optional< std::string > | incrbyfloat (std::string_view key, double increment) |
Increment the floating point number stored at key by increment . More... | |
| template<typename... Args> | |
| std::optional< std::vector< std::string > > | mget (Args &&... keys) |
| Get the values of multiple keys atomically. More... | |
| template<typename... Args> | |
| std::optional< std::string > | mset (Args &&... keys) |
| Set multiple key-value pairs. More... | |
| template<typename... Args> | |
| std::optional< std::string > | msetnx (Args &&... keys) |
| Set the given key-value pairs if all specified keys do not exist. More... | |
| std::optional< std::string > | psetex (std::string_view key, uint64_t ttl, std::string_view val) |
| Set key-value pair with the given timeout in milliseconds. More... | |
| template<RedisSetValueType T> | |
| std::optional< std::string > | set (std::string_view key, T val, uint64_t ttl=0, RedisTTLType ttl_type=RedisTTLType::EX, UpdateType type=UpdateType::ALWAYS) |
| Set a key-value pair. More... | |
| std::optional< std::string > | setex (std::string_view key, uint64_t ttl, std::string_view val) |
| Set key-value pair with the given timeout in seconds. More... | |
| std::optional< uint64_t > | setnx (std::string_view key, std::string_view val) |
| Set the key if it does not exist. More... | |
| std::optional< uint64_t > | setrange (std::string_view key, uint64_t offset, std::string_view val) |
Set the substring starting from offset to the given value. More... | |
| std::optional< uint64_t > | strlen (std::string_view key) |
| Get the length of the string stored at key. More... | |
| std::optional< uint64_t > | llen (std::string_view key) |
| Get the length of the list. More... | |
| std::optional< std::string > | lpop (std::string_view key) |
| Pop the first element of the list. More... | |
| std::optional< uint64_t > | lpush (std::string_view key, std::string_view val) |
| Push an element to the beginning of the list. More... | |
| template<typename... Args> | |
| std::optional< uint64_t > | lpush (std::string_view key, Args &&... keys) |
| Push multiple elements to the beginning of the list. More... | |
| std::optional< uint64_t > | lpushx (std::string_view key, std::string_view val) |
| Push an element to the beginning of the list, only if the list already exists. More... | |
| std::optional< std::vector< std::string > > | lrange (std::string_view key, uint64_t start, uint64_t stop) |
| Get elements in the given range of the given list. More... | |
| std::optional< uint64_t > | lrem (std::string_view key, uint64_t count, std::string_view val) |
Remove the first count occurrences of elements equal to val . More... | |
| std::optional< std::string > | lset (std::string_view key, uint64_t index, std::string_view val) |
| Set the element at the given index to the specified value. More... | |
| std::optional< std::string > | ltrim (std::string_view key, uint64_t start, uint64_t stop) |
| Trim a list to keep only element in the given range. More... | |
| std::optional< std::string > | rpop (std::string_view key) |
| Pop the last element of a list. More... | |
| std::optional< std::string > | rpoplpush (std::string_view source, std::string_view destination) |
| Pop last element of one list and push it to the left of another list. More... | |
| template<typename... Args> | |
| std::optional< uint64_t > | rpush (std::string_view key, std::string_view val, Args &&... vals) |
| Push an element to the end of the list. More... | |
| std::optional< uint64_t > | rpushx (std::string_view key, std::string_view val) |
| Push an element to the end of the list, only if the list already exists. More... | |
| template<typename... Args> | |
| std::optional< uint64_t > | hdel (std::string_view key, std::string_view field, Args &&... fields) |
| Remove the given field from hash. More... | |
| std::optional< uint64_t > | hexists (std::string_view key, std::string_view field) |
| Check if the given field exists in hash. More... | |
| std::optional< std::string > | hget (std::string_view key, std::string_view field) |
| Get the value of the given field. More... | |
| std::optional< std::vector< std::string > > | hgetall (std::string_view key) |
| Get all field-value pairs of the given hash. More... | |
| std::optional< uint64_t > | hincrby (std::string_view key, std::string_view field, uint64_t increment) |
| Increment the integer stored at the given field. More... | |
| std::optional< double > | hincrbyfloat (std::string_view key, std::string_view field, double increment) |
| Increment the floating point number stored at the given field. More... | |
| std::optional< std::vector< std::string > > | hkeys (std::string_view key) |
| Get all fields of the given hash. More... | |
| std::optional< uint64_t > | hlen (std::string_view key) |
| Get the number of fields of the given hash. More... | |
| template<typename... Args> | |
| std::optional< std::vector< std::string > > | hmget (std::string_view key, std::string_view field, Args &&... fields) |
| Get values of multiple fields. More... | |
| template<typename... Args> | |
| std::optional< std::string > | hmset (std::string_view key, std::string_view field, std::string_view value, Args &&... args) |
| Set multiple field-value pairs of the given hash. More... | |
| std::optional< scan_ret_t > | hscan (std::string_view key, uint64_t cursor, uint64_t count) |
| Scan fields of the given hash matching the given pattern. More... | |
| std::optional< scan_ret_t > | hscan (std::string_view key, uint64_t cursor, std::string_view pattern, uint64_t count=0) |
| Scan fields of the given hash matching the given pattern. More... | |
| template<typename... Args> | |
| std::optional< uint64_t > | hset (std::string_view key, std::string_view field, std::string_view val, Args &&... args) |
| Set hash field to value. More... | |
| std::optional< uint64_t > | hset (std::string_view key, const std::vector< std::pair< std::string_view, std::string_view >> &kvs) |
| Set multiple fields of the given hash. More... | |
| std::optional< uint64_t > | hsetnx (std::string_view key, std::string_view field, std::string_view val) |
| Set hash field to value, only if the given field does not exist. More... | |
| std::optional< uint64_t > | hstrlen (std::string_view key, std::string_view field) |
| Get the length of the string stored at the given field. More... | |
| std::optional< std::vector< std::string > > | hvals (std::string_view key) |
| Get values of all fields stored at the given hash. More... | |
| template<typename... Args> | |
| std::optional< uint64_t > | sadd (std::string_view key, std::string_view member, Args &&... members) |
| Add a member to the given set. More... | |
| std::optional< uint64_t > | scard (std::string_view key) |
| Get the number of members in the set. More... | |
| template<typename... Args> | |
| std::optional< std::vector< std::string > > | sdiff (std::string_view key, Args &&... keys) |
| Get the difference between the first set and all successive sets. More... | |
| template<typename... Args> | |
| std::optional< uint64_t > | sdiffstore (std::string_view destination, std::string_view key, Args &&... keys) |
Copy set stored at key to destination . More... | |
| template<typename... Args> | |
| std::optional< std::vector< std::string > > | sinter (std::string_view key, Args &&... keys) |
| Get the intersection between the first set and all successive sets. More... | |
| template<typename... Args> | |
| std::optional< uint64_t > | sinterstore (std::string_view destination, std::string_view key, Args &&... keys) |
Copy set stored at key to destination . More... | |
| std::optional< uint64_t > | sismember (std::string_view key, std::string_view member) |
Test if member exists in the set stored at key. More... | |
| std::optional< std::vector< std::string > > | smembers (std::string_view key) |
| Get all members in the given set. More... | |
| std::optional< uint64_t > | smove (std::string_view source, std::string_view destination, std::string_view member) |
Move member from one set to another. More... | |
| std::optional< std::vector< std::string > > | spop (std::string_view key, uint64_t count=1) |
| Remove a random member from the set. More... | |
| std::optional< std::string > | srandmember (std::string_view key) |
| Get a random member of the given set. More... | |
| std::optional< std::vector< std::string > > | srandmember (std::string_view key, uint64_t count) |
| Get multiple random members of the given set. More... | |
| template<typename... Args> | |
| std::optional< uint64_t > | srem (std::string_view key, std::string_view member, Args &&... members) |
| Remove a member from set. More... | |
| std::optional< scan_ret_t > | sscan (std::string_view key, uint64_t cursor, uint64_t count) |
| Scan members of the set matching the given pattern. More... | |
| std::optional< scan_ret_t > | sscan (std::string_view key, uint64_t cursor, std::string_view pattern, uint64_t count=0) |
| template<typename... Args> | |
| std::optional< uint64_t > | sunion (std::string_view key, Args &&... keys) |
| Get the union between the first set and all successive sets. More... | |
| template<typename... Args> | |
| std::optional< uint64_t > | sunionstore (std::string_view destination, std::string_view key, Args &&... keys) |
Copy set stored at key to destination . More... | |
| std::optional< std::vector< std::string > > | bzpopmax (std::initializer_list< std::string_view > keys, uint64_t timeout=0) |
| Pop the member with highest score from sorted set in a blocking way. More... | |
| std::optional< std::vector< std::string > > | bzpopmin (std::initializer_list< std::string_view > keys, uint64_t timeout=0) |
| Pop the member with lowest score from sorted set in a blocking way. More... | |
| std::optional< uint64_t > | zadd (std::string_view key, std::string_view member, double score, UpdateType type=UpdateType::ALWAYS) |
| Add or update a member with score to sorted set. More... | |
| std::optional< uint64_t > | zadd (std::string_view key, std::vector< std::pair< std::string_view, double >> kvs, UpdateType type=UpdateType::ALWAYS) |
| Add or update multiple members with score to sorted set. More... | |
| template<typename T > | |
| std::optional< uint64_t > | zadd (std::string_view key, std::initializer_list< T > il, UpdateType type=UpdateType::ALWAYS, bool changed=false) |
| Add or update multiple members with score to sorted set. More... | |
| std::optional< uint64_t > | zcard (std::string_view key) |
| Get the number of members in the sorted set. More... | |
| std::optional< uint64_t > | zcount (std::string_view key, std::string_view min, std::string_view max) |
| Get the number of members with score between a min-max score range. More... | |
| std::optional< double > | zincrby (std::string_view key, double increment, std::string_view member) |
| Increment the score of given member. More... | |
| std::optional< uint64_t > | zlexcount (std::string_view key, std::string_view min, std::string_view max) |
| Get the number of members between a min-max range in lexicographical order. More... | |
| std::optional< std::vector< std::string > > | zpopmax (std::string_view key, uint64_t count=1) |
| Pop the member with highest score from sorted set. More... | |
| std::optional< std::vector< std::string > > | zpopmin (std::string_view key) |
| Pop the member with lowest score from sorted set. More... | |
| std::optional< std::vector< std::string > > | zrange (std::string_view key, std::string_view min, std::string_view max) |
| Get a range of members by rank (ordered from lowest to highest). More... | |
| std::optional< std::vector< std::string > > | zrangebylex (std::string_view key, std::string_view min, std::string_view max) |
| Get a range of members by lexicographical order (from lowest to highest). More... | |
| std::optional< std::vector< std::string > > | zrangebyscore (std::string_view key, std::string_view min, std::string_view max) |
| Get a range of members by score (ordered from lowest to highest). More... | |
| std::optional< uint64_t > | zrank (std::string_view key, std::string_view member) |
| Get the rank (from low to high) of the given member in the sorted set. More... | |
| template<typename... Args> | |
| std::optional< uint64_t > | zrem (std::string_view key, std::string_view member, Args &&... members) |
| Remove the given member from sorted set. More... | |
| std::optional< uint64_t > | zremrangebylex (std::string_view key, std::string_view min, std::string_view max) |
| Remove members in the given range of lexicographical order. More... | |
| std::optional< uint64_t > | zremrangebyrank (std::string_view key, uint64_t start, uint64_t stop) |
| Remove members in the given range ordered by rank. More... | |
| std::optional< uint64_t > | zremrangebyscore (std::string_view key, std::string_view min, std::string_view max) |
| Remove members in the given range ordered by score. More... | |
| std::optional< std::string > | zrevrange (std::string_view key, uint64_t start, uint64_t stop, bool withscores=false) |
| Get a range of members by rank (ordered from highest to lowest). More... | |
| std::optional< std::string > | zrevrangebylex (std::string_view key, std::string_view min, std::string_view max) |
| Get a range of members by lexicographical order (from highest to lowest). More... | |
| template<typename Interval , typename Output > | |
| std::optional< std::string > | zrevrangebyscore (std::string_view key, std::string_view min, std::string_view max) |
| Get a range of members by score (ordered from highest to lowest). More... | |
| std::optional< uint64_t > | zrevrank (std::string_view key, std::string_view member) |
| Get the rank (from high to low) of the given member in the sorted set. More... | |
| std::optional< uint64_t > | zscan (std::string_view key, uint64_t cursor, uint64_t count) |
| Scan all members of the given sorted set. More... | |
| std::optional< scan_ret_t > | zscan (std::string_view key, uint64_t cursor, std::string_view pattern, uint64_t count) |
| Scan all members of the given sorted set. More... | |
| std::optional< double > | zscore (std::string_view key, std::string_view member) |
| Get the score of the given member. More... | |
| std::optional< uint64_t > | zunionstore (std::string_view destination, std::initializer_list< std::string_view > keys, std::string_view aggregate="SUM") |
| Copy a sorted set to another one with the scores being multiplied by a factor. More... | |
| std::optional< uint64_t > | zunionstore (std::string_view destination, std::vector< std::pair< std::string_view, double >> kvs, std::string_view aggregate="SUM") |
| Get union of multiple sorted sets, and store the result to another one. More... | |
| template<typename... Args> | |
| std::optional< uint64_t > | pfadd (std::string_view key, Args &&... elements) |
| Add the given element to a hyperloglog. More... | |
Synchronous connection.
|
inline |
construction
| ctx | Redis synchronous context |
|
inline |
Append the given string to the string stored at key.
| key | Key. |
| str | String to be appended. |
|
inline |
Send password to Redis.
| password | Password. |
ConnectionOptions
or URI.
|
inline |
Send user and password to Redis.
| user | User name. |
| password | Password. |
ConnectionOptions
or URI. Also this overload only works with Redis 6.0 or later.
|
inline |
Rewrite AOF in the background.
|
inline |
Save database in the background.
|
inline |
Get the number of bits that have been set for the given range of the string.
| key | Key. |
| start | Start index (inclusive) of the range. 0 means the beginning of the string. |
| end | End index (inclusive) of the range. -1 means the end of the string. |
|
inline |
Do bit operation on the string stored at key
, and save the result to destination
.
| op | Bit operations. |
| destination | The destination key where the result is saved. |
| key | The key where the string to be operated is stored. |
destination
. BitOp
|
inline |
Get the position of the first bit set to 0 or 1 in the given range of the string.
| key | Key. |
| bit | 0 or 1. |
| start | Start index (inclusive) of the range. 0 means the beginning of the string. |
| end | End index (inclusive) of the range. -1 means the end of the string. |
|
inline |
Pop the member with highest score from sorted set in a blocking way.
| key | Key where the sorted set is stored. |
| timeout | Timeout in seconds. 0 means block forever. |
Redis::zpopmax
|
inline |
Pop the member with lowest score from sorted set in a blocking way.
| key | Key where the sorted set is stored. |
| timeout | Timeout in seconds. 0 means block forever. |
bzpopmin
returns Optional<std::tuple<std::string, std::string, double>>{}
(std::nullopt
). Redis::zpopmin
|
inline |
Send redis command.
| cmd | Redis command. |
|
inline |
Get the size of the currently selected database.
|
inline |
Decrement the integer stored at key by 1.
| key | Key. |
|
inline |
Decrement the integer stored at key by decrement
.
| key | Key. |
| decrement | Decrement. |
|
inline |
Delete the given key.
| key | Key. |
| 1 | If the key exists, and has been removed. |
| 0 | If the key does not exist. |
|
inline |
Get the serialized valued stored at key.
| key | Key. |
dump
returns OptionalString{}
(std::nullopt
).
|
inline |
Ask Redis to return the given message.
| msg | Message to be sent. |
|
inline |
Check if the given key exists.
| key | Key. |
| 1 | If key exists. |
| 0 | If key does not exist. |
|
inline |
Set a timeout on key.
| key | Key. |
| timeout | Timeout in seconds. |
| 1 | If timeout has been set. |
| 0 | If key does not exist. |
|
inline |
Set a timeout on key, i.e. expire the key at a future time point.
| key | Key. |
| timestamp | Time in seconds since UNIX epoch. |
| true | If timeout has been set. |
| false | If key does not exist. |
|
inline |
Remove keys of all databases.
| async | Whether flushing databases asynchronously, i.e. without blocking the server. |
|
inline |
Remove keys of current databases.
| async | Whether flushing databases asynchronously, i.e. without blocking the server. |
|
inline |
Get the string value stored at key.
Example:
| key | Key. |
get
returns OptionalString{}
(std::nullopt
).
|
inline |
Get the bit value at offset in the string.
| key | Key. |
| offset | Offset. |
|
inline |
Get the substring of the string stored at key.
| key | Key. |
| start | Start index (inclusive) of the range. 0 means the beginning of the string. |
| end | End index (inclusive) of the range. -1 means the end of the string. |
|
inline |
Atomically set the string stored at key
to val
, and return the old value.
| key | Key. |
| val | Value to be set. |
getset
returns OptionalString{}
(std::nullopt
). OptionalString
|
inline |
Remove the given field from hash.
| key | Key where the hash is stored. |
| field | Field to be removed. |
| 1 | If the field exists, and has been removed. |
| 0 | If the field does not exist. |
|
inline |
Check if the given field exists in hash.
| key | Key where the hash is stored. |
| field | Field. |
| true | If the field exists in hash. |
| false | If the field does not exist. |
|
inline |
Get the value of the given field.
| key | Key where the hash is stored. |
| field | Field. |
hget
returns OptionalString{}
(std::nullopt
).
|
inline |
Get all field-value pairs of the given hash.
Example:
| key | Key where the hash is stored. |
| output | Output iterator to the destination where the result is saved. |
hgetall
on a large hash, since it will block Redis. Redis::hscan
|
inline |
Increment the integer stored at the given field.
| key | Key where the hash is stored. |
| field | Field. |
| increment | Increment. |
|
inline |
Increment the floating point number stored at the given field.
| key | Key where the hash is stored. |
| field | Field. |
| increment | Increment. |
|
inline |
Get all fields of the given hash.
| key | Key where the hash is stored. |
| output | Output iterator to the destination where the result is saved. |
hkeys
on a large hash, since it will block Redis. Redis::hscan
|
inline |
Get the number of fields of the given hash.
| key | Key where the hash is stored. |
|
inline |
Get values of multiple fields.
Example:
| key | Key where the hash is stored. |
| first | Iterator to the first field. |
| last | Off-the-end iterator to the given field range. |
| output | Output iterator to the destination where the result is saved. |
OptionalString
type, since the given field might not exist (in this case, the value of the corresponding field is OptionalString{}
(std::nullopt
)).
|
inline |
Set multiple field-value pairs of the given hash.
Example:
| key | Key where the hash is stored. |
| first | Iterator to the first field-value pair. |
| last | Off-the-end iterator to the range. |
|
inline |
Scan fields of the given hash matching the given pattern.
| key | Key where the hash is stored. |
| cursor | Cursor. |
| pattern | Pattern of fields to be scanned. |
| output | Output iterator to the destination where the result is saved. |
|
inline |
Scan fields of the given hash matching the given pattern.
Example:
| key | Key where the hash is stored. |
| cursor | Cursor. |
| pattern | Pattern of fields to be scanned. |
| count | A hint for how many fields to be scanned. |
| output | Output iterator to the destination where the result is saved. |
|
inline |
Set multiple fields of the given hash.
Example:
| key | Key where the hash is stored. |
| first | Iterator to the first field to be set. |
| last | Off-the-end iterator to the given range. |
|
inline |
Set hash field to value.
| key | Key where the hash is stored. |
| field | Field. |
| val | Value. |
| true | If the given field didn't exist, and a new field has been added. |
| false | If the given field already exists, and its value has been overwritten. |
hset
returns false, it does not mean that the method failed to set the field. Instead, it means that the field already exists, and we've overwritten its value. If hset
fails, it will throw an exception of Exception
type.
|
inline |
Set hash field to value, only if the given field does not exist.
| key | Key where the hash is stored. |
| field | Field. |
| val | Value. |
| true | If the field has been set. |
| false | If failed to set the field, i.e. the field already exists. |
|
inline |
Get the length of the string stored at the given field.
| key | Key where the hash is stored. |
| field | Field. |
|
inline |
Get values of all fields stored at the given hash.
| key | Key where the hash is stored. |
| output | Output iterator to the destination where the result is saved. |
hvals
on a large hash, since it might block Redis. Redis::hscan
|
inline |
Increment the integer stored at key by 1.
| key | Key. |
|
inline |
Increment the integer stored at key by increment
.
| key | Key. |
| increment | Increment. |
|
inline |
Increment the floating point number stored at key by increment
.
| key | Key. |
| increment | Increment. |
|
inline |
|
inline |
Get the info about the server on the given section.
| section | Section. |
|
inline |
Get the UNIX timestamp in seconds, at which the database was saved successfully.
|
inline |
Get the length of the list.
| key | Key where the list is stored. |
|
inline |
Pop the first element of the list.
Example:
| key | Key where the list is stored. |
OptionalString{}
(std::nullopt
).
|
inline |
Push multiple elements to the beginning of the list.
Example:
| key | Key where the list is stored. |
| first | Iterator to the first element to be pushed. |
| last | Off-the-end iterator to the given element range. |
|
inline |
Push an element to the beginning of the list.
| key | Key where the list is stored. |
| val | Element to be pushed. |
|
inline |
Push an element to the beginning of the list, only if the list already exists.
| key | Key where the list is stored. |
| val | Element to be pushed. |
|
inline |
Get elements in the given range of the given list.
Example:
| key | Key where the list is stored. |
| start | Start index of the range. Index can be negative, which mean index from the end. |
| stop | End index of the range. |
| output | Output iterator to the destination where the results are saved. |
|
inline |
Remove the first count
occurrences of elements equal to val
.
| key | Key where the list is stored. |
| count | Number of occurrences to be removed. |
| val | Value. |
count
can be positive, negative and 0. Check the reference for detail.
|
inline |
Set the element at the given index to the specified value.
| key | Key where the list is stored. |
| index | Index of the element to be set. |
| val | Value. |
|
inline |
Trim a list to keep only element in the given range.
| key | Key where the key is stored. |
| start | Start of the index. |
| stop | End of the index. |
|
inline |
Get the values of multiple keys atomically.
Example:
| first | Iterator to the first key of the given range. |
| last | Off-the-end iterator to the given range. |
| output | Output iterator to the destination where the values are stored. |
OptionalString
type, since the given key might not exist (in this case, the value of the corresponding key is OptionalString{}
(std::nullopt
)).
|
inline |
Get keys matching the given pattern.
| pattern | Pattern. |
| output | Output iterator to the destination where the returned keys are stored. |
keys
, since it might block Redis for a long time, especially when the data set is very big. Redis::scan
Move a key to the given database.
| key | Key. |
| db | The destination database. |
| true | If key has been moved. |
| false | If key was not moved. |
|
inline |
Set multiple key-value pairs.
Example:
| il | Initializer list of key-value pairs. |
|
inline |
Set the given key-value pairs if all specified keys do not exist.
Example:
| first | Iterator to the first key-value pair. |
| last | Off-the-end iterator of the given range. |
| true | If all keys have been set. |
| false | If no key was set, i.e. at least one key already exist. |
|
inline |
Remove timeout on key.
| key | Key. |
| true | If timeout has been removed. |
| false | If key does not exist, or does not have an associated timeout. |
|
inline |
Set a timeout on key.
| key | Key. |
| timeout | Timeout in milliseconds. |
| true | If timeout has been set. |
| false | If key does not exist. |
|
inline |
Set a timeout on key, i.e. expire the key at a future time point.
| key | Key. |
| timestamp | Time in milliseconds since UNIX epoch. |
| true | If timeout has been set. |
| false | If key does not exist. |
|
inline |
Add the given element to a hyperloglog.
| key | Key of the hyperloglog. |
| element | Element to be added. |
| true | If at least one internal register has been altered. |
| false | If none of internal registers has been altered. |
pfadd
returns false, it does not mean that this method failed to add an element to the hyperloglog. Instead it means that the internal registers were not altered. If pfadd
fails, it will throw an exception of Exception
type.
|
inline |
|
inline |
Test if the connection is alive.
| msg | Message sent to Redis. |
|
inline |
Set key-value pair with the given timeout in milliseconds.
| key | Key. |
| ttl | Time-To-Live in milliseconds. |
| val | Value. |
|
inline |
Get the TTL of a key in milliseconds.
| key | Key. |
|
inline |
After sending QUIT, only the current connection will be close, while other connections in the pool is still open.
|
inline |
Get a random key from current database.
randomkey
returns OptionalString{}
(std::nullopt
).
|
inline |
Rename key
to newkey
.
| key | Key to be renamed. |
| newkey | The new name of the key. |
|
inline |
Rename key
to newkey
if newkey
does not exist.
| key | Key to be renamed. |
| newkey | The new name of the key. |
| true | If key has been renamed. |
| false | If newkey already exists. |
|
inline |
Create a key with the value obtained by Redis::dump
.
| key | Key. |
| val | Value obtained by Redis::dump . |
| ttl | Timeout of the created key in milliseconds. If ttl is 0, set no timeout. |
| replace | Whether to overwrite an existing key. If replace is true and key already exists, throw an exception. |
|
inline |
Pop the last element of a list.
| key | Key where the list is stored. |
rpop
returns OptionalString{}
(std::nullopt
).
|
inline |
Pop last element of one list and push it to the left of another list.
| source | Key of the source list. |
| destination | Key of the destination list. |
rpoplpush
returns OptionalString{}
(std::nullopt
).
|
inline |
Push an element to the end of the list.
| key | Key where the list is stored. |
| val | Element to be pushed. |
|
inline |
Push an element to the end of the list, only if the list already exists.
| key | Key where the list is stored. |
| val | Element to be pushed. |
|
inline |
Add a member to the given set.
| key | Key where the set is stored. |
| member | Member to be added. |
| 1 | The member did not exist before, and it has been added now. |
| 0 | The member already exists before this operation. |
|
inline |
Save databases into RDB file synchronously, i.e. block the server during saving.
|
inline |
Scan keys of the database matching the given pattern.
Example:
| cursor | Cursor. |
| pattern | Pattern of the keys to be scanned. |
| count | A hint for how many keys to be scanned. |
| output | Output iterator to the destination where the returned keys are stored. |
|
inline |
Get the number of members in the set.
| key | Key where the set is stored. |
|
inline |
Get the difference between the first set and all successive sets.
| first | Iterator to the first set. |
| last | Off-the-end iterator to the range. |
| output | Output iterator to the destination where the result is saved. |
|
inline |
Copy set stored at key
to destination
.
| destination | Key of the destination set. |
| key | Key of the source set. |
|
inline |
Select the Redis logical database.
|
inline |
Set a key-value pair.
Example:
| key | Key. |
| val | Value. |
| ttl | Timeout on the key. If ttl is 0ms, do not set timeout. |
| type | Options for set command:
|
| true | If the key has been set. |
| false | If the key was not set, because of the given option. |
|
inline |
Set key-value pair with the given timeout in seconds.
| key | Key. |
| ttl | Time-To-Live in seconds. |
| val | Value. |
|
inline |
Set the key if it does not exist.
| key | Key. |
| val | Value. |
| true | If the key has been set. |
| false | If the key was not set, i.e. the key already exists. |
|
inline |
Set the substring starting from offset
to the given value.
| key | Key. |
| offset | Offset. |
| val | Value. |
|
inline |
Get the intersection between the first set and all successive sets.
| first | Iterator to the first set. |
| last | Off-the-end iterator to the range. |
| output | Output iterator to the destination where the result is saved. |
|
inline |
Copy set stored at key
to destination
.
| destination | Key of the destination set. |
| key | Key of the source set. |
|
inline |
Test if member
exists in the set stored at key.
| key | Key where the set is stored. |
| member | Member to be checked. |
member
exists in the set. | true | If it exists in the set. |
| false | If it does not exist in the set, or the given key does not exist. |
|
inline |
Get all members in the given set.
Example:
| key | Key where the set is stored. |
| output | Iterator to the destination where the result is saved. |
|
inline |
Move member
from one set to another.
| source | Key of the set in which the member currently exists. |
| destination | Key of the destination set. |
| true | If the member has been moved. |
| false | If member does not exist in source . |
|
inline |
Remove a random member from the set.
| key | Key where the set is stored. |
spop
returns OptionalString{}
(std::nullopt
). Redis::srandmember
|
inline |
Get a random member of the given set.
| key | Key where the set is stored. |
srandmember
returns OptionalString{}
(std::nullopt
). Redis::spop
|
inline |
Get multiple random members of the given set.
| key | Key where the set is stored. |
| count | Number of members to be returned. |
| output | Output iterator to the destination where the result is saved. |
Redis::spop
|
inline |
Remove a member from set.
| key | Key where the set is stored. |
| member | Member to be removed. |
| 1 | If the given member exists, and has been removed. |
| 0 | If the given member does not exist. |
|
inline |
Scan members of the set matching the given pattern.
Example:
| key | Key where the set is stored. |
| cursor | Cursor. |
| pattern | Pattern of fields to be scanned. |
| count | A hint for how many fields to be scanned. |
| output | Output iterator to the destination where the result is saved. |
|
inline |
Get the length of the string stored at key.
| key | Key. |
strlen
returns 0.
|
inline |
Get the union between the first set and all successive sets.
| first | Iterator to the first set. |
| last | Off-the-end iterator to the range. |
| output | Output iterator to the destination where the result is saved. |
|
inline |
Copy set stored at key
to destination
.
| destination | Key of the destination set. |
| key | Key of the source set. |
|
inline |
Swap two Redis databases.
| idx1 | The index of the first database. |
| idx2 | The index of the second database. |
|
inline |
Update the last access time of the given key.
| key | Key. |
| 1 | If key exists, and last access time has been updated. |
| 0 | If key does not exist. |
|
inline |
Get the remaining Time-To-Live of a key.
| key | Key. |
| TTL | If the key has a timeout. |
| -1 | If the key exists but does not have a timeout. |
| -2 | If the key does not exist. |
ttl
returns -1 if the key does not exist, or if the key exists but does not have a timeout.
|
inline |
Get the type of the value stored at key.
| key | Key. |
|
inline |
Remove the given key asynchronously, i.e. without blocking Redis.
| key | Key. |
| 1 | If key exists, and has been removed. |
| 0 | If key does not exist. |
|
inline |
Wait until previous write commands are successfully replicated to at least the specified number of replicas or the given timeout has been reached.
| numslaves | Number of replicas. |
| timeout | Timeout in milliseconds. If timeout is 0ms, wait forever. |
numslaves
, because timeout has been reached.
|
inline |
Add or update multiple members with score to sorted set.
Example:
| key | Key where the sorted set is stored. |
| first | Iterator to the first member-score pair. |
| last | Off-the-end iterator to the member-score pairs range. |
| type | Options for zadd command:
|
| changed | Whether change the return value from number of newly added member to number of members changed (i.e. added and updated). |
changed
. @see
UpdateType`
|
inline |
Add or update a member with score to sorted set.
| key | Key where the sorted set is stored. |
| member | Member to be added. |
| score | Score of the member. |
| type | Options for zadd command:
|
| changed | Whether change the return value from number of newly added member to number of members changed (i.e. added and updated). |
changed
. @see
UpdateType`
|
inline |
Add or update multiple members with score to sorted set.
Example:
| key | Key where the sorted set is stored. |
| first | Iterator to the first member-score pair. |
| last | Off-the-end iterator to the member-score pairs range. |
| type | Options for zadd command:
|
| changed | Whether change the return value from number of newly added member to number of members changed (i.e. added and updated). |
changed
. @see
UpdateType`
|
inline |
Get the number of members in the sorted set.
| key | Key where the sorted set is stored. |
|
inline |
Get the number of members with score between a min-max score range.
Example:
| key | Key where the sorted set is stored. |
| interval | The min-max score range. |
BoundedInterval
LeftBoundedInterval
RightBoundedInterval
UnboundedInterval
BoundType
|
inline |
Increment the score of given member.
| key | Key where the sorted set is stored. |
| increment | Increment. |
| member | Member. |
|
inline |
Get the number of members between a min-max range in lexicographical order.
| key | Key where the sorted set is stored. |
| interval | The min-max range in lexicographical order. |
BoundedInterval
LeftBoundedInterval
RightBoundedInterval
UnboundedInterval
BoundType
|
inline |
Pop the member with highest score from sorted set.
| key | Key where the sorted set is stored. |
zpopmax
returns Optional<std::pair<std::string, double>>{}
(std::nullopt
). Redis::bzpopmax
|
inline |
Pop the member with lowest score from sorted set.
| key | Key where the sorted set is stored. |
zpopmin
returns Optional<std::pair<std::string, double>>{}
(std::nullopt
). Redis::bzpopmin
|
inline |
Get a range of members by rank (ordered from lowest to highest).
Example:
| key | Key where the sorted set is stored. |
| start | Start rank. Inclusive and can be negative. |
| stop | Stop rank. Inclusive and can be negative. |
| output | Output iterator to the destination where the result is saved. |
output
is an iterator to a container of std::string
, we send ZRANGE key start stop command. If it's an iterator to a container of std::pair<std::string, double>
, we send ZRANGE key start stop WITHSCORES command. See the Example part on how to use this method. Redis::zrevrange
|
inline |
Get a range of members by lexicographical order (from lowest to highest).
Example:
| key | Key where the sorted set is stored. |
| interval | the min-max range by lexicographical order. |
| output | Output iterator to the destination where the result is saved. |
Redis::zlexcount
's Example part for how to set interval
parameter. Redis::zlexcount
BoundedInterval
LeftBoundedInterval
RightBoundedInterval
UnboundedInterval
BoundType
Redis::zrevrangebylex
|
inline |
Get a range of members by score (ordered from lowest to highest).
Example:
| key | Key where the sorted set is stored. |
| interval | the min-max range by score. |
| output | Output iterator to the destination where the result is saved. |
output
is an iterator to a container of std::string
, we send ZRANGEBYSCORE key min max command. If it's an iterator to a container of std::pair<std::string, double>
, we send ZRANGEBYSCORE key min max WITHSCORES command. See the Example part on how to use this method. Redis::zcount
's Example part for how to set the interval
parameter. Redis::zrevrangebyscore
|
inline |
Get the rank (from low to high) of the given member in the sorted set.
| key | Key where the sorted set is stored. |
| member | Member. |
zrank
returns OptionalLongLong{}
(std::nullopt
).
|
inline |
Remove the given member from sorted set.
| key | Key where the sorted set is stored. |
| member | Member to be removed. |
| 1 | If the member exists, and has been removed. |
| 0 | If the member does not exist. |
|
inline |
Remove members in the given range of lexicographical order.
| key | Key where the sorted set is stored. |
| interval | the min-max range by lexicographical order. |
Redis::zlexcount
's Example part for how to set interval
parameter. Redis::zlexcount
BoundedInterval
LeftBoundedInterval
RightBoundedInterval
UnboundedInterval
BoundType
|
inline |
Remove members in the given range ordered by rank.
| key | Key where the sorted set is stored. |
| start | Start rank. |
| stop | Stop rank. |
|
inline |
Remove members in the given range ordered by score.
| key | Key where the sorted set is stored. |
| interval | the min-max range by score. |
Redis::zcount
's Example part for how to set the interval
parameter.
|
inline |
Get a range of members by rank (ordered from highest to lowest).
Example:
| key | Key where the sorted set is stored. |
| start | Start rank. Inclusive and can be negative. |
| stop | Stop rank. Inclusive and can be negative. |
| output | Output iterator to the destination where the result is saved. |
output
is an iterator to a container of std::string
, we send ZREVRANGE key start stop command. If it's an iterator to a container of std::pair<std::string, double>
, we send ZREVRANGE key start stop WITHSCORES command. See the Example part on how to use this method. Redis::zrange
|
inline |
Get a range of members by lexicographical order (from highest to lowest).
Example:
| key | Key where the sorted set is stored. |
| interval | the min-max range by lexicographical order. |
| output | Output iterator to the destination where the result is saved. |
Redis::zlexcount
's Example part for how to set interval
parameter. Redis::zlexcount
BoundedInterval
LeftBoundedInterval
RightBoundedInterval
UnboundedInterval
BoundType
Redis::zrangebylex
|
inline |
Get a range of members by score (ordered from highest to lowest).
Example:
| key | Key where the sorted set is stored. |
| interval | the min-max range by score. |
| output | Output iterator to the destination where the result is saved. |
output
is an iterator to a container of std::string
, we send ZREVRANGEBYSCORE key min max command. If it's an iterator to a container of std::pair<std::string, double>
, we send ZREVRANGEBYSCORE key min max WITHSCORES command. See the Example part on how to use this method. Redis::zcount
's Example part for how to set the interval
parameter. Redis::zrangebyscore
|
inline |
Get the rank (from high to low) of the given member in the sorted set.
| key | Key where the sorted set is stored. |
| member | Member. |
zrevrank
returns OptionalLongLong{}
(std::nullopt
).
|
inline |
Scan all members of the given sorted set.
| key | Key where the sorted set is stored. |
| cursor | Cursor. |
| output | Output iterator to the destination where the result is saved. |
|
inline |
Scan all members of the given sorted set.
| key | Key where the sorted set is stored. |
| cursor | Cursor. |
| count | A hint for how many members to be scanned. |
| output | Output iterator to the destination where the result is saved. |
|
inline |
Get the score of the given member.
| key | Key where the sorted set is stored. |
| member | Member. |
zscore
returns OptionalDouble{}
(std::nullopt
).
|
inline |
Copy a sorted set to another one with the scores being multiplied by a factor.
| destination | Key of the destination sorted set. |
| key | Key of the source sorted set. |
| weight | Weight to be multiplied to the score of each member. |
Redis::zinterstore
|
inline |
Get union of multiple sorted sets, and store the result to another one.
Example:
| destination | Key of the destination sorted set. |
| first | Iterator to the first sorted set (might with weight). |
| last | Off-the-end iterator to the sorted set range. |
| type | How the scores are aggregated.
|
Input
is an iterator to a container of std::string
, we use the default weight, i.e. 1, and send ZUNIONSTORE dest numkeys key [key ...] [AGGREGATE SUM|MIN|MAX] command. If Input
is an iterator to a container of std::pair<std::string, double>
, i.e. key-weight pair, we send the command with the given weights: ZUNIONSTORE dest numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX]. See the Example part for examples on how to use this command. Redis::zinterstore


There are several types of deployments we might have - a single artifact/environment combination, multiple artifacts, multiple environments, or composite deployments.


--- layout: page ---
This project is an exploration of program translation using compiler design techniques. Given a syntactically
correct code written in Object Oriented Perl the tool developed here programmatically generates an equivalent code
in Python which generates identical outputs. Using a lexer and a 2 stage parser, translation of several concepts
unique to OOPerl to Python was achieved.
Conference paper: Skanda, V. C. Jayaram, Rachana. Kumar, N. S. (2021). Refactoring OOPerl and Translating it to Python. In Innovative Data Communication Technologies and Application (pp. 375–386). Springer Singapore.
Language:
Python, Perl.
Tools & technologies used:
Python Lex and Yacc library.
This project involves interleaving lengthy lecture videos with questionnaires at optimal moments in order to keep
students’ attention. MCQ type questions are generated based on the transcript of the video lecture using ML and NLP
techniques. In order to maintain continuity and proper flow of teaching, a LDA-based model is used to insert these
generated questions at appropriate points during the lecture.
Conference paper: Skanda, V. C. Jayaram, Rachana. Kumar, N. S. (2020). Automatic Questionnaire and Interactive Session Generation from Videos. In Computational Intelligence in Data Science (pp. 205–212). Springer International Publishing.
Language:
Python.
Tools & technologies used:
Spacy, Keras, Natural Language Toolkit, Sklearn.
Using machine learning models to predict the probability of a windows system getting infected by various families of
malware, based on different properties of that system. This was done by using gradient boosting frameworks, namely a
LightGBM model on Microsoft's 'Malware Prediction' dataset.
Language:
Python.
Tools & technologies used:
Light GBM, Keras, Sklearn.
This is a project in cryptography that involves implementing image encryption using various chaos maps and comparing
their
merits based on key sensitivity, adjacent pixel autocorrelation and intensity histograms. The chaos maps implemented
were - Arnold cat maps, Henon maps and Logistic chaos maps.
Language:
Python.
A teaching tool that is meant for easy visualization of Dijkstra's algorithm which is used to find the shortest
path from a single source vertex to all other vertices in a given graph.
Language:
JavaScript, Python.
Tools & technologies used:
Sigma JS for graph drawing, flask.
This project involves implementing a generic segment tree using C++. A segment tree is a data structure that is used for answering range queries over an series of elements effectively, while still being flexible enough to allow updating values of the elements.
The project is an online movie booking website where a user can register, login, and book tickets for a movie of their choice.
The project involved making a mock elective registration website for our university. Using this portal, students can sign up for electives of their choice and teachers can monitor the head-count of students enrolled in their elective.
Email<EMAIL_ADDRESS>LinkedIn : RachanaJayaram@LinkedIn
Github : github.com/RachanaJayaram
Find my resume


{% extends "common/templates/email/base.html" %} {% block body %}
{{actor.display_nick}}, your {{SITE_NAME}} password has been reset. Click on the link to view the new password and sign in. You can then change it in Settings.
Get new password


{% extends 'layout-af.html' %} {% block pageTitle %} Armed forces Healthcare {% endblock %} {% block beforeContent %} {% endblock %} {% block content %}
Find mental health information and support for serving personnel, mobilised reservists and families.
Mental health problems are common and can affect anyone, including serving personnel, mobilised reservists and their families. It is important to get help and support if you or someone you know is struggling with mental health.
Some people delay getting help with their mental health for a number of reasons, such as trying to cope alone, fear of criticism, embarrassment or feeling that the NHS will not understand.
There are many different ways to get help that take you and your situation into account. Finding the right support for you is important.
If you need support for a specific mental health condition, you can find information through our A-Z of mental health conditions.
If you want help from a charity, you can:
All serving personnel and mobilised reservists receive mental health treatment and care from military mental health professionals no matter where you are based.
If you need them, military healthcare professionals may refer you to specialist mental health services. These services are all specially commissioned by the MoD.
The priority of all specialist mental health services is to return you to your regular armed forces work as quickly and safely as possible.
Departments of Community Mental Health (DCMH) offer specialist outpatient mental health care in the UK. These are military centres dedicated to treating serving personnel military health problems.
Smaller DCMH centres are also available overseas.
Specialist inpatient mental health care services for serving personnel are provided by several NHS trusts across the country.
Service personnel are assessed, stabilised and treated in hospitals as close to their home or parent unit as possible.
If you need to talk to somebody, Combat Stress have a dedicated mental health support helpline for serving personnel and their families. This provides confidential advice and support and is free to call for serving personnel, family members and carers.
This helpline is available 24 hours a day, 365 days a year on 0800 323 4444.
Togetherall is a mental health support service providing anonymous, round-the-clock online support with trained counsellors.
There's a supportive community and lots of free resources that all armed forces serving personnel and their families can use at any time.
{% endblock %}


Air quality in Delhi-NCR improves due to strong winds
by PTIThe air quality in Delhi improved significantly on Sunday due to strong winds but continued to remain in the "poor" category.
The satellite cities of the national capital also saw significant improvement in the air quality with some having Air Quality Index (AQI) in the "moderate" category.
The air quality in Delhi-NCR is expected to remain in the "moderate" and "poor" categories for the next two days.
At 4 pm, the AQI of Delhi was recorded at 215, which falls in the "poor" category.
The AQI in Faridabad was 197 (moderate), Ghaziabad 218 (poor), Greater Noida 202 (poor), Noida 203 (poor) and Gurgaon 136 (moderate).
An AQI between 201 and 300 is considered "poor", 301-400 "very poor" and 401-500 severe".
On Saturday, Delhi's AQI was recorded at 357, which falls in the "very poor" category.
Mahesh Talawat, vice president of Sky Met weather, said strong winds due to western disturbance has helped dispersed pollutants in Delhi-NCR and other parts of north India.
"The air quality is expected to remain in 'moderate' to 'poor' category in the next two days," he said.
The national capital recorded a maximum temperature of 29 degrees Celsius and a minimum temperature of 16.2 degrees Celsius on Sunday.
The humidity oscillated between 85 per cent and 45 per cent, respectively.
The weatherman has forecast strong surface winds during the daytime on Monday with the maximum temperature touching 27 degrees Celsius and a minimum of 15 degrees Celsius.
Delhi was blanketed with a thick smog for four consecutive days till Friday as unfavourable weather hampered dispersion of pollutants.


the and NoV that vaccine was with for :â€". (). are al.. norovirus GII. were have infection from {background been can immune Norovirus GI. vaccines However, against margin not response Infect effective has {border-style The antibody bivalent development px;} #ffffff;} Dis. Moreover, this years (NoV) both disease protection subjects those virus when AGE VLPs these adults after most studies other shown than This all containing due levels particle two NoV-specific acute immunogenicity some study viral GII VLP Vaccine antigens associated burden cause children common gastroenteritis genotypes higher human induce infections only particles which Î¼g Virol. adenovirus cases challenge could found immunocompromised incidence patients phase responses risk virus-like ./j.vaccine... :e. Finally, IgA Vaccine. able although antibodies any capsid diarrhea group included increase outbreaks problems px; specific {font-family â€" Development HBGA-blocking Vaccines age among based clinical doses even font-size healthy infection. lower more norwalk recent recombinant rotavirus same serum strain strains systematic vaccine, years, < Clin PLoS cells cellular combination combined compared contrast, countries different double; given global heterologous high including increased induced old preparation preparations protein received related reported revealed significant significantly trial use vaccination viruses (), NoV, Norwalk analysis animal animals because before between border-color border-width candidate cell days developed developed. differences evaluate evidenced expressing formulation frequently had health highly identification illness influenza lead led mainly may mice. must number one potential potentially prevention protective receiving results role safe solid; such susceptibility system used whether will without {font-style {font-weight .), ./journal.pone. Clinical FUT GII., Genetic Intranasal ONE. Studies VLPs, Vaxart adjuvanted administration age. aged antigenic asymptomatic availability bold but capable collected courier; data delivery derived develop diarrhoeal domain dose during economic em; episodes extremely further gastroenteritis. genotype genotype. immunity immunization infection, infectious intestinal intramuscular intranasal its know level many memory mild models monovalent occur oral people population possible protection. pt;} rates reduced response, several severe similar single slightly solved tested their they total trials vaccine. weeks where younger


Energy, Control Engineering, Optimization, and ML - II
My last post discussed control engineering at a rather high level. In this post, I will include a bit more technical stuff in order to illustrate a comparison with optimization and ML.
Energy
Many control problems can be defined in the following generic form: given states $x$ (which could be and often is a vector), control input $u$, and known system dynamics $\dot{x} = f( x, u )$, find a choice of $u$ to make $x$ converge to some desired states $x_d$.
Using the pendulum example from my previous post again, the state $x$ can be chosen to be the orientation of the pendulum along with the angular velocity $x = ( \theta, \dot\theta )$. Why do we need the velocity term? Then we have $\dot x = ( \dot\theta, \textrm{some equation})$, where some equation is the equation of motion for $\ddot \theta$ as a function of $m$, $\theta$, $l$, and $u$. In this case, $u=\tau$ is the input torque at the pivot. If the goal is to stabilize the pendulum at certain orientation $\theta_d$, then we have $x_d = ( \theta_d, 0)$.
The essence of the energy-based control that was discussed in my last post is to understand the natural energy that is present in the system, identify ways to “replace” it with an artificial form that favors the target $x_d$ as the globally stable equilibrium point. For a fully actuated system (meaning that you can exert input independently in the direction of each degree of freedom), it is often very easy to find $u$ once the artificial energy is well-defined, so the challenge is usually find the artificial energy itself. Because the artificial energy is usually taken as the Lyapunov function, we denote is as $V(x, \dot x)$. Loosely speaking, if you can prove that $V$ is at its minimum at $(x=x_d, \dot x=0)$, and that $V$ monotonically decreases over time (i.e. $\dot V(x, \dot x, u) <0)$, then we know that the desired states will eventually be reached.
Optimization and ML
Of course there is no Lyapunov function in optimization, but instead we have a scalar function that defines the cost to be minimized: $J(x,y,\theta)$. Here $x$ is the input data, $y$ is the output data, and $\theta$ is the model parameters (weights and biases in the neural network, for instance). My apologies for mixing the use of $x$ and $\theta$, but I was following the most widely used conventions in both controls and optimization so please bear with me here.
In most cases, it is impossible to get a closed-form solution to the optimization problem, so we have to figure out other ways to decrease $J$. The most widely used method is an iterative one, often based on the gradient - backpropagation in neural networks is a great example of this. In each iteration, the goal is to gradually decrease $J$ by adjusting $\theta$ - i.e. we aim to find some update rule $\theta_{i+1} \leftarrow g(\theta_i, \frac{\partial J}{\partial \theta_i})$ where $i$ denotes the time step or number of iterations, so that $J_{i+1} < J_i$. To make it *a bit* more concrete, the vanilla gradient descent rule has $\theta_{i+1} \leftarrow \theta_i - \alpha \frac{\partial J}{\partial \theta_i}$, and with a suitable choice of $\alpha$ we know the cost will decrease after each iteration.
I personally found this very similar to energy-based control. In the end, in both cases the goal is to minimize certain scalar function $V$ or $J$. There is no direct notion of “time derivative” in optimization, but the update rule is no different from a discrete system in control engineering. If we make the update step small enough (very small $\alpha$ in gradient descent, for example), it can be perceived as a continuous time control system. This goes along with the analogy that gradient descent is similar to a ball rolling downhill in a complex high-dimensional space (I actually have some slight disagreement about this analogy and will discuss this in a future post).
Comparison Chart
| Control Engineering | ML Optimization | Notes | |
|---|---|---|---|
| Scalar Function | Lyapunov function $V$ | Cost function $J$ | Usually $J$ is given for an optimization problem, but finding a suitable $V$ is often the hardest step in control |
| “Space” | State space of $x$ | Space of all possible model parameters $\theta$ | |
| Initial Condition | Usually constrained by initial condition $x(t=0) = x_0$ | Free to initialize $\theta$ | |
| Objective | Make $x \rightarrow x_d$ (target configuration). In doing so we minimize $V$ | Minimize cost $J$. In doing so we reach some optimal parameters $\theta_d$ | The target configuration $x_d$ is always given in control, but we never know $\theta_d$ ahead of time - otherwise there’s no point working on optimization! |
| “Input” | Input is $u$ which goes in the system dynamics: $\dot x = f(u, x)$. We are constrained by this $f(u, x)$ which defines how the input affects the system | The “input” is the update rule itself, free of constraints: $\theta_{i+1} \leftarrow g(\theta_i, \frac{\partial J}{\partial \theta_i})$ | |
| “Dynamics” | Dynamics of the closed-loop system - “energy always tends to decrease” | Gradient-based optimization - “rolling downhill” aka “energy always tends to decrease” |
Looking back at this post I almost feel that this is a rambling note and there should be better ways to tell the story. If you have any questions or suggestions please feel out to reach out!


--- title: wdkbsp keywords: fastai sidebar: home_sidebar summary: "API details." description: "API details." nb_path: "00_core.ipynb" ---
hi
hi()
'Hi There!'


On this page you will find pictures and information about the various microorganisms found in many freshwater environments, including those in Santa Cruz, CA.
Daphnia
The daphnia , or commonly referred to as "water flea", is found in
many freshwater bodies. The transparency of
the daphnia's skin allows us to see the functioning organs inside. Often the daphnia carries
multiple eggs, which can be seen in this photo in the middle right region of its body.
Copepod
The copepod often accompanies the daphnia in the freshwater
environment. It is a common source
of nutrients among the fish. It falls under the classification of a crustacean and can be found
in most bodies of water. Their diet consists mainly of phytoplankton.
Mosquito Larvae
Usually found in calm fresh bodies of water are mosquito larvae.
When removed from water they
sqirm around chaotically like a fish out of water. They can survive in the worst and best of
water conditions, hence their presence all throughout the world
Hydra
Hydra are some of the most interesting creatures due to their ability
to not age. They have tentacles that retract when anticipating danger.
They are found mainly in tropical regions and are also a source of food for fish.
Dragonfly Larvae
Female dragonflies lay their eggs on plants or in water. The eggs hatch into larvae
and can survive in both the water and land.
Once they begin to mature they shed their outer layer of skin, spread their wings and fly away. Fish
feed on the dragonfly larvae and are a major food source in some environments.