A collection of functions for factor screening, global sensitivity analysis and reliability sensitivity analysis. Most of the functions have to be applied on model with scalar output, but several functions support multi-dimensional outputs.
| Version: | 1.15.2 |
| Depends: | R (≥ 3.0.0) |
| Imports: | boot, methods |
| Suggests: | condMVNorm, DiceDesign, DiceKriging, evd, fanovaGraph, ggplot2, ggExtra, gtools, igraph, ks, mc2d, mvtnorm, numbers, parallel, pracma, randtoolbox, reshape2, rgl, triangle |
| Published: | 2018-09-02 |
| Author: | Bertrand Iooss, Alexandre Janon and Gilles Pujol, with contributions from Khalid Boumhaout, Sebastien Da Veiga, Thibault Delage, Jana Fruth, Laurent Gilquin, Joseph Guillaume, Loic Le Gratiet, Paul Lemaitre, Barry L. Nelson, Filippo Monari, Roelof Oomen, Oldrich Rakovec, Bernardo Ramos, Olivier Roustant, Eunhye Song, Jeremy Staum, Roman Sueur, Taieb Touati, Frank Weber |
| Maintainer: | Bertrand Iooss <biooss at yahoo.fr> |
| License: | GPL-2 |
| NeedsCompilation: | yes |
| Materials: | NEWS |
| In views: | Environmetrics |
| CRAN checks: | sensitivity results |
| Reference manual: | sensitivity.pdf |
| Package source: | sensitivity_1.15.2.tar.gz |
| Windows binaries: | r-devel: sensitivity_1.15.2.zip, r-release: sensitivity_1.15.2.zip, r-oldrel: sensitivity_1.15.2.zip |
| OS X binaries: | r-release: sensitivity_1.15.2.tgz, r-oldrel: sensitivity_1.15.2.tgz |
| Old sources: | sensitivity archive |
| Reverse depends: | ATmet, fanovaGraph, mtk, ODEsensitivity |
| Reverse imports: | LSDsensitivity, multisensi, rrepast |
| Reverse suggests: | BayesianTools, GNE, pse |
Please use the canonical form https://CRAN.R-project.org/package=sensitivity to link to this page.


logger = require 'winston'
cli = require("cli").enable "help", "version", "glob"
path = require "path"
JsCpd = require "./../jscpd"
TokenizerFactory = require '../tokenizer/TokenizerFactory'
logger.cli()
cli.setUsage "jscpd [OPTIONS]"
cli.setApp path.resolve "#{__dirname}/../../package.json"
cli.parse {
"min-lines": ['l', "min size of duplication in code lines", "number", 5]
"min-tokens": ['t', "mim size of duplication in code tokens", "number", 70]
"files": ['f', "glob pattern for find code", "string"]
"exclude": ['e', "directory to ignore", "string"],
"skip-comments": [false, "skip comments in code"],
"blame": ['b', "blame authors of duplications (get information about authors from git)"],
"languages": [
'g'
"list of languages which scan for duplicates, separated with comma"
"string", Object.keys(TokenizerFactory::LANGUAGES).join ','
]
"output": ['o', "path to report file", "path"],
"reporter": ['r', "reporter to use", "string", "xml"],
"xsl-href": ['x', "path to xsl for include to xml report", "string"],
"verbose": [off, "show full info about copies"]
"debug": ['d', "show debug information(options list and selected files)"]
"path": ['p', "path to code", "path"]
"limit": [
off
'limit of allowed duplications, if real duplications percent more then limit jscpd exit with error'
"number"
50
]
}
cli.main (args, options) ->
jscpd = new JsCpd
logger.profile "All time:"
logger.info """
jscpd - copy/paste detector for programming source code, developed by Andrey Kucherenko
"""
jscpd.run options
logger.profile "All time:"
|


MEAN Scaffolding Generator
Main Class
Mongoose Models
New
Save
Check
Atribute
NodeJS
Mongoose Model
API Controller
Web Controller
HTML
HTML List
HTML New
HTML Edit
HTML View
AngularJS
Angular Controller
Angular Factory
Mongoose Model
app/models/
API Controller
app/controllers/
Web Controller
app/controllers/
Html List
app/views/
Html New
app/views/
Html Edit
app/views/
Html View
app/views/
View
Angular Controller
public/angular/controllers
Angular Factory
public/angular/factory


After reading parts of Wasson's SOMA, I was curious to try fly agaric for myself, to see what effects it might have. I was a little apprehensive because I'd heard that some people have had less-than-pleasant experiences (nausea, profuse sweating, drowsiness, etc.). But I thought the benefits might outweigh any drawbacks.
I picked a small mushroom, for two reasons: first, they are said to be more active; second, I didn't want to overdo it, not knowing what might happen. I let it dry for a week or so in my closet, which may seem like a strange place, but it had been raining, and I wanted it to dry properly. It shrank considerably; I was able to roll it up into a kind of ball and, after letting it soften in my mouth, swallow it whole. I didn't chew it because I thought I might avoid nausea that way.
I made sure to do it in a secluded spot, a very beautiful spot, called Redwood Grove. I knew that I would be alone there to do anything I pleased: write, sing, laugh, throw up, jump around and talk to trees. However, the trip, if it can be called that, was very mild. I never felt out of control. There were some side effects: I felt a fairly sharp pain in my groin and lower abdomen, but I was able to alleviate it with regular breathing. Also, I noticed that I was sweating more than I would have normally and that my vision was not as acute. Specifically, I couldn't focus on distant objects. At one point, I was hiking out of the grove and saw the moon over the ridge to my right. It appeared to me as a bright blur of light, and I couldn't make out any of its features (the craters and mountains we see as the Man in the Moon). It was just a blob in the sky. Distant lights in houses below were similarly blurry. My vision later corrected itself.
Overall, it was milder and more uneventful than I expected. It's hard for me to say just how it affected me: I don't know that I was any more aware, or that I saw or heard things that I wouldn't have without the mushroom (heightened senses). I think I may have become more contemplative, but that will happen to anyone who spends four hours among Redwood trees. Still, I felt a kind of communion with the natural world, which should happen anytime we consume something that is of the earth but often doesn't.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


XestiMonitors
Overview
The XestiMonitors framework provides more than sixty fully-functional monitor classes right out of the box that make it easy for your app to detect and respond to many common system-generated events.
Among other things, you can think of XestiMonitors as a better way to manage
the most common notifications (primarily on iOS and tvOS). At present,
XestiMonitors provides “wrappers” around nearly all UIKit
notifications (see
UIKit Monitors) and many Foundation
notifications (see
Foundation Monitors).
XestiMonitors also provides convenient “wrappers” around several frameworks and programming interfaces to make them easier for your app to use:
- It wraps the Core Location framework to make it easier for your app to make easier for your app to determine the device’s geographic location, altitude, or orientation; or its position relative to a nearby iBeacon. See Core Location Monitors for details.
- It wraps the Core Motion framework to make it easier for your app to obtain both raw and processed motion measurements from the device. See Core Motion Monitors for details.
- It wraps the
SCNetworkReachability
programming interface to make it super easy for your app to determine the reachability of a target host. See Other Monitors for details.
Additional monitors targeting more parts of all four platforms will be rolled out in future releases of XestiMonitors!
Finally, XestiMonitors is extensible—you can easily create your own custom monitors. See Custom Monitors for details.
Reference Documentation
Full reference documentation is available courtesy of Jazzy.
Requirements
- iOS 9.0+ / macOS 10.10+ / tvOS 9.0+ / watchOS 2.0+
- Xcode 9.0+
- Swift 4.0+
Installation
CocoaPods
CocoaPods is a dependency manager for Cocoa projects. You can install it with the following command:
$ gem install cocoapods
To integrate XestiMonitors into your Xcode project using CocoaPods, specify it
in your Podfile
:
source 'https://github.com/CocoaPods/Specs.git'
platform :ios, '9.0'
use_frameworks!
target '<Your Target Name>' do
pod 'XestiMonitors'
end
Then, run the following command:
$ pod install
Carthage
Carthage is a decentralized dependency manager that builds your dependencies and provides you with binary frameworks.
You can install Carthage with Homebrew using the following commands:
$ brew update
$ brew install carthage
To integrate XestiMonitors into your Xcode project using Carthage, specify it
in your Cartfile
:
github "eBardX/XestiMonitors"
Then, run the following command:
$ carthage update
Finally, drag the built XestiMonitors.framework
into your Xcode project.
Swift Package Manager
The Swift Package Manager is a tool for automating the distribution of Swift code and is integrated into the swift compiler. It is in early development, but XestiMonitors does support its use on supported platforms.
Once you have your Swift package set up, adding XestiMonitors as a dependency
is as easy as adding it to the dependencies
value of your Package.swift
.
dependencies: [
.Package(url: "https://github.com/eBardX/XestiMonitors.git")
]
Usage
All monitor classes conform to the Monitor protocol, thus enabling you to create arrays of monitors that can be started or stopped uniformly—fewer lines of code!

Core Location Monitors
XestiMonitors provides seven monitor classes wrapping the Core Location framework that you can use to determine the device’s geographic location, altitude, or orientation; or its position relative to a nearby iBeacon:
- BeaconRangingMonitor to monitor a region for changes to the ranges (i.e., the relative proximity) to the Bluetooth low-energy beacons within. (iOS)
- HeadingMonitor to monitor the device for changes to its current heading. (iOS)
- LocationAuthorizationMonitor to monitor the app for updates to its authorization to use location services. (iOS, macOS, tvOS, watchOS)
- RegionMonitor to monitor a region for changes to its state (which indicate boundary transitions). (iOS, macOS)
- SignificantLocationMonitor to monitor the device for significant changes to its current location. (iOS, macOS)
- StandardLocationMonitor to monitor the device for changes to its current location. (iOS, macOS, tvOS, watchOS)
- VisitMonitor to monitor for locations that the user stops at for a “noteworthy” amount of time. (iOS)
Core Motion Monitors
XestiMonitors provides seven monitor classes wrapping the Core Motion framework that you can use to obtain raw and processed motion measurements from the device:
- AccelerometerMonitor to monitor the device’s accelerometer for periodic raw measurements of the acceleration along the three spatial axes. (iOS, watchOS)
- AltimeterMonitor to monitor the device for changes in relative altitude. (iOS, watchOS)
- DeviceMotionMonitor to monitor the device’s accelerometer, gyroscope, and magnetometer for periodic raw measurements which are processed into device motion measurements. (iOS, watchOS)
- GyroscopeMonitor to monitor the device’s gyroscope for periodic raw measurements of the rotation rate around the three spatial axes. (iOS, watchOS)
- MagnetometerMonitor to monitor the device’s magnetometer for periodic raw measurements of the magnetic field around the three spatial axes. (iOS, watchOS)
- MotionActivityMonitor to monitor the device for live and historic motion data. (iOS, watchOS)
- PedometerMonitor to monitor the device for live and historic walking data. (iOS, watchOS)
Foundation Monitors
XestiMonitors provides seventeen monitors wrapping
Foundation
notifications:
- BundleClassLoadMonitor to monitor a bundle for dynamic loads of classes. (iOS, macOS, tvOS, watchOS)
- BundleResourceRequestMonitor to monitor the system to detect if the amount of available disk space for on-demand resources is getting low. (iOS, tvOS, watchOS)
- CalendarDayMonitor to monitor the system for changes to the calendar day. (iOS, macOS, tvOS, watchOS)
- CurrentLocaleMonitor to monitor the system for changes to the user’s locale. (iOS, macOS, tvOS, watchOS)
- ExtensionHostMonitor to monitor an extension context for changes to the runtime state of the extension’s host app. (iOS, tvOS, watchOS)
- [HTTPCookiesStorageMonitor][http_cookies_storage_monitor] instance to monitor an HTTP cookie storage object for changes to its acceptance policy or to its cookies. (iOS, macOS, tvOS, watchOS)
- MetadataQueryMonitor to monitor a metadata query for changes to its results. (iOS, macOS, tvOS, watchOS)
- PortMonitor to monitor a port for changes to its validity. (iOS, macOS, tvOS, watchOS)
- ProcessInfoPowerStateMonitor to monitor the device for changes to its power state (Low Power Mode is enabled or disabled). (iOS, tvOS, watchOS)
- ProcessInfoThermalStateMonitor to monitor the system for changes to the thermal state. (iOS, macOS, tvOS, watchOS)
- SystemClockMonitor to monitor the system for changes to the clock. (iOS, macOS, tvOS, watchOS)
- SystemTimeZoneMonitor to monitor the system for changes to the currently used time zone. (iOS, macOS, tvOS, watchOS)
- UbiquitousKeyValueStoreMonitor to monitor the iCloud (“ubiquitous”) key-value store for changes due to incoming data pushed from iCloud. (iOS, macOS, tvOS)
- UbiquityIdentityMonitor to monitor the system for changes to the iCloud (”ubiquity”) identity. (iOS, macOS, tvOS, watchOS)
- UndoManagerMonitor to monitor an undo manager for changes to its recording of operations. (iOS, macOS, tvOS, watchOS)
- URLCredentialStorageMonitor to monitor the shared URL credential storage object for changes to its stored credentials. (iOS, macOS, tvOS, watchOS)
- UserDefaultsMonitor to monitor a user defaults object for changes to its data. (iOS, macOS, tvOS, watchOS)
UIKit Monitors
XestiMonitors provides numerous monitors wrapping
UIKit
notifications.
Accessibility Monitors
XestiMonitors provides three monitor classes that you can use to observe accessibility events generated by the system:
- AccessibilityAnnouncementMonitor to monitor the system for accessibility announcements that VoiceOver has finished outputting. (iOS, tvOS)
- AccessibilityElementMonitor to monitor the system for changes to element focus by an assistive technology. (iOS, tvOS)
- AccessibilityStatusMonitor to monitor the system for changes to the status of various accessibility settings. (iOS, tvOS)
Application Monitors
XestiMonitors provides seven monitor classes that you can use to observe common events generated by the system about the app:
- ApplicationStateMonitor to monitor the app for changes to its runtime state. (iOS, tvOS)
- BackgroundRefreshMonitor to monitor the app for changes to its status for downloading content in the background. (iOS)
- MemoryMonitor to monitor the app for memory warnings from the operating system. (iOS, tvOS)
- ProtectedDataMonitor to monitor the app for changes to the accessibility of protected files. (iOS, tvOS)
- ScreenshotMonitor to monitor the app for screenshots. (iOS, tvOS)
- StatusBarMonitor to monitor the app for changes to the orientation of its user interface or to the frame of the status bar. (iOS)
- TimeMonitor to monitor the app for significant changes in time. (iOS, tvOS)
Device Monitors
XestiMonitors provides three monitor classes that you can use to detect changes in the characteristics of the device:
- BatteryMonitor to monitor the device for changes to the charge state and charge level of its battery. (iOS)
- OrientationMonitor to monitor the device for changes to its physical orientation. (iOS)
- ProximityMonitor to monitor the device for changes to the state of its proximity sensor. (iOS)
Screen Monitors
XestiMonitors provides four monitor classes that you can use to detect changes in the properties associated with a screen:
- ScreenBrightnessMonitor to monitor a screen for changes to its brightness level. (iOS, tvOS)
- ScreenCapturedMonitor to monitor a screen for changes to its captured status. (iOS, tvOS)
- ScreenConnectionMonitor to monitor the device for screen connections and disconnections. (iOS, tvOS)
- ScreenModeMonitor to monitor a screen for changes to its current mode. (iOS, tvOS)
Text Monitors
XestiMonitors provides four monitor classes that you can use to detect changes in text input mode and content:
- TextFieldTextMonitor to monitor a text field for changes to its text. (iOS, tvOS)
- TextInputModeMonitor to monitor the responder chain for changes to the current input mode. (iOS, tvOS)
- TextStorageMonitor to monitor a text storage for the processing of edits to its contents. (iOS, tvOS)
- TextViewTextMonitor to monitor a text view for changes to its text. (iOS, tvOS)
Other UIKit Monitors
In addition, XestiMonitors provides nine other UIKit
monitors:
- ContentSizeCategoryMonitor to monitor the app for changes to its preferred content size category. (iOS, tvOS)
- DocumentStateMonitor to monitor a document for changes to its state. (iOS)
- FocusMonitor to monitor the app for changes to the current focus in the view hierarchy. (iOS, tvOS)
- KeyboardMonitor to monitor the keyboard for changes to its visibility or to its frame. (iOS)
- MenuControllerMonitor to monitor the menu controller for changes to the visibility of the editing menu or to the frame of the editing menu. (iOS)
- PasteboardMonitor to monitor a pasteboard for changes to its contents or for its removal from the app. (iOS)
- TableViewSelectionMonitor to monitor a table view for changes to its selected row. (iOS, tvOS)
- ViewControllerShowDetailTargetMonitor to monitor the app for changes to a split view controller’s display mode in the view hierarchy. (iOS, tvOS)
- WindowMonitor to monitor a window for changes to its visibility or key status. (iOS, tvOS)
KeyboardMonitor is especially handy in removing lots of boilerplate code from your app. This is how keyboard monitoring is typically handled in a custom view controller:
func keyboardWillHide(_ notification: Notification) {
let userInfo = notification.userInfo
var animationDuration: TimeInterval = 0
if let value = (userInfo?[UIKeyboardAnimationDurationUserInfoKey] as? NSNumber)?.doubleValue {
animationDuration = value
}
constraint.constant = 0
UIView.animate(withDuration: animationDuration) {
self.view.layoutIfNeeded()
}
}
func keyboardWillShow(_ notification: Notification) {
let userInfo = notification.userInfo
var animationDuration: TimeInterval = 0
if let value = (userInfo?[UIKeyboardAnimationDurationUserInfoKey] as? NSNumber)?.doubleValue {
animationDuration = value
}
var frameEnd = CGRect.zero
if let value = (userInfo?[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue {
frameEnd = value
}
constraint.constant = frameEnd.height
UIView.animate(withDuration: animationDuration) {
self.view.layoutIfNeeded()
}
}
override func viewWillAppear(_ animated: Bool) {
super.viewWillAppear(animated)
let nc = NotificationCenter.`default`
nc.addObserver(self, selector: #selector(keyboardWillHide(_:)),
name: .UIKeyboardWillHide, object: nil)
nc.addObserver(self, selector: #selector(keyboardWillShow(_:)),
name: .UIKeyboardWillShow, object: nil)
}
override func viewWillDisappear(_ animated: Bool) {
NotificationCenter.`default`.removeObserver(self)
super.viewWillDisappear(animated)
}
And this is the XestiMonitors way using KeyboardMonitor:
import XestiMonitors
lazy var keyboardMonitor = KeyboardMonitor { [unowned self] event in
guard let constraint = self?.constraint,
let view = self?.view else { return }
switch event {
case let .willHide(info):
constraint.constant = 0
UIView.animate(withDuration: info.animationDuration) {
view.layoutIfNeeded()
}
case let .willShow(info):
constraint.constant = info.frameEnd.height
UIView.animate(withDuration: info.animationDuration) {
view.layoutIfNeeded()
}
default:
break
}
}
override func viewWillAppear(_ animated: Bool) {
super.viewWillAppear(animated)
keyboardMonitor.startMonitoring()
}
override func viewWillDisappear(_ animated: Bool) {
keyboardMonitor.stopMonitoring()
super.viewWillDisappear(animated)
}
What’s in your wallet?
Other Monitors
In addition, XestiMonitors provides two other monitors:
- FileSystemObjectMonitor to monitor a file-system object for changes. (iOS, macOS, tvOS, watchOS)
- NetworkReachabilityMonitor to monitor a network node name or address for changes to its reachability. (iOS, macOS, tvOS)
Custom Monitors
Best of all, the XestiMonitors framework provides several ways to create your own custom monitors quite easily.
Implementing the Monitor Protocol
You can create a new class, or extend an existing class, that conforms to the Monitor protocol. You need only implement the startMonitoring() and stopMonitoring() methods, as well as the isMonitoring property:
import XestiMonitors
extension MegaHoobieWatcher: Monitor {
var isMonitoring: Bool { return watchingForHoobiesCount() > 0 }
func startMonitoring() -> Bool {
guard !isMonitoring else { return }
beginWatchingForHoobies()
}
func stopMonitoring() -> Bool {
guard isMonitoring else { return }
endWatchingForHoobies()
}
}
Note: The guard statements in both startMonitoring() and stopMonitoring() protect against starting or stopping the monitor if it is in the incorrect state. This is considered good coding practice.
Subclassing the BaseMonitor Class
Typically, you will want to create a subclass of BaseMonitor.
The advantage of using this abstract base class is that the basic guard logic
is taken care of for you. Specifically, the
startMonitoring() method does not attempt to start the
monitor if it is already active, and the stopMonitoring()
method does not attempt to stop the monitor if it is not active. Instead of
directly implementing the required protocol methods and properties, you need
only override the configureMonitor() and
cleanupMonitor() methods of this base class. In fact, you
will not be able to override the startMonitoring() and
stopMonitoring() methods or the
isMonitoring property—they are declared final
in
BaseMonitor.
import XestiMonitors
class GigaHoobieMonitor: BaseMonitor {
let handler: (Float) -> Void
@objc let hoobie: GigaHoobie
private var observation: NSKeyValueObservation?
init(_ hoobie: GigaHoobie, handler: @escaping (Float) -> Void) {
self.handler = handler
self.hoobie = hoobie
}
override func configureMonitor() -> Bool {
super.configureMonitor()
observation = hoobie.observe(\.nefariousActivityLevel) { [unowned self] hoobie, _ in
self.handler(hoobie.nefariousActivityLevel) }
}
override func cleanupMonitor() -> Bool {
observation?.invalidate()
observation = nil
super.cleanupMonitor()
}
}
Note: Be sure to invoke the superclass implementations of both configureMonitor() and cleanupMonitor().
Subclassing the BaseNotificationMonitor Class
If your custom monitor determines events by observing notifications, you should
consider creating a subclass of
BaseNotificationMonitor instead. In most cases you
need only override the
addNotificationObservers(_:) method. You can
also override the
removeNotificationObservers(_:) method if
you require extra cleanup when the notification observers are removed upon
stopping the monitor. Although this base class inherits from
BaseMonitor, you will not be able to override the
configureMonitor() and
cleanupMonitor() methods—they are declared final
in
BaseNotificationMonitor.
import XestiMonitors
class TeraHoobieMonitor: BaseNotificationMonitor {
let handler: (Bool) -> Void
let hoobie: TeraHoobie
init(hoobie: TeraHoobie, queue: OperationQueue = .main,
handler: @escaping (Bool) -> Void) {
self.handler = handler
self.hoobie = hoobie
super.init(queue: queue)
}
override func addNotificationObservers() -> Bool {
super.addNotificationObservers()
observe(.teraHoobieDidChange) { [unowned self] _ in
self.handler(self.hoobie.value) }
}
}
Note: Be sure to invoke the superclass implementations of both addNotificationObservers(_:) and removeNotificationObservers(_:) in your overrides.
Credits
J. G. Pusey<EMAIL_ADDRESS>License
XestiMonitors is available under the MIT license.


[gecode-users] How to set an arbitrary RandomGenerator for randomized branching?!?
Javier Andrés Mena Zapata
javimena at gmail.com
Mon May 18 18:31:50 CEST 2009
Hi,
Just curiosity... Do you prefer RNG speed, RNG space, general speed or
general space?
Cheers,
On Mon, May 18, 2009 at 2:55 AM, Mikael Zayenz Lagerkvist
<zayenz at gmail.com>wrote:
> Hi,
>
> Currently it is not possible to exchange the random number generator.
> Furthermore, the implementation uses properties of the random number
> generator that would most probably compromise efficiency if they were
> abstracted away (for example, the state is limited to a single
> unsigned int as seed). If you want to use your own random number
> generator, I would suggest writing your own subclasses of ViewSelBase
> and ValSelbase similar to ViewSelRnd and ValRnd.
>
> For curiosity, what is the reason that you want to change the random
> number generator used?
>
> Cheers,
> Mikael
>
> On Sat, May 16, 2009 at 12:37 AM, Martin Mann
> <mmann at informatik.uni-freiburg.de> wrote:
> >
> > Hi everybody,
> >
> > I digged a bit into the Gecode source about the randomized branching
> > supported since version 3.
> >
> > In line 124 in gecode/support/random.hpp I found the definition of
> > RandomGenerator internally used in the view selection:
> >
> >
> http://www.gecode.org/doc-latest/reference/group__FuncSupport.html#g02fe942f90a57a25639f09960dab4459
> >
> > As given there, it is just a typedef onto the
> > LinearCongruentialGenerator provided by Gecode but I would like to set
> > up my own random number generator...
> >
> > Is there a possibility to support user defined generators? e.g. in
> > coming versions?
> >
> > If not available right now, maybe you like the following suggestion:
> >
> > A possibility would be a super class 'RNG' that has to be implemented by
> > every generator plus a kind of factory class 'RNF' with static members
> only.
> > The RNF would be a wrapper around the current RNG instance to use
> > (stored in a static internal member). Thus, all Gecode internals that
> > need a random number use a static interface of RNF instead of some RNG
> > instance members. So the library gets independent of the concrete RNG
> > used and you get the possibility to register a user defined RNG within
> > the RNF. Per default the RNF can use the linear congruential generator
> > provided. The static interface and data member would avoid annoying
> > copies of RNGs all around and won't complicate your Gecode
> internals/source.
> >
> >
> > Just a suggestion... if it is already possible just ignore and please
> > let me know how to do with the current Gecode version. :)
> >
> >
> > Have a nice weekend,
> >
> > Martin
> >
> >
> > _______________________________________________
> > Gecode users mailing list
> > users at gecode.org
> > https://www.gecode.org/mailman/listinfo/gecode-users
> >
>
>
>
> --
> Mikael Zayenz Lagerkvist, http://www.ict.kth.se/~zayenz/<http://www.ict.kth.se/%7Ezayenz/>
>
> _______________________________________________
> Gecode users mailing list
> users at gecode.org
> https://www.gecode.org/mailman/listinfo/gecode-users
>
--
"La buena educación, es lo que nos queda cuando se nos olvida todo lo que
nos han enseñado"
¿?
Javier Andrés Mena Zapata
http://StrategicDecision.net/
+57 (2) 318 1000 ext. 2910
Cali - Colombia
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.ps.uni-sb.de/pipermail/users/attachments/20090518/7b6a362f/attachment.htm>
More information about the gecode-users
mailing list


Find a fresh, fun scent!
All fragrances!
$1 Tarts Wax Melts®, Samplers® Votive Candles and Car Jar® Air Fresheners
To shop now, copy and paste:
http://links.mkt1917.com/ctt?kn=25&ms=MTI3OTc4MDgS1&r=Mzc1MTMwMDUwMTIS1&b=2&j=NzAzNjU4MzUzS0&mt=1&rt=0
into your browser
To find a store near you, copy and paste:
http://links.mkt1917.com/ctt?kn=18&ms=MTI3OTc4MDgS1&r=Mzc1MTMwMDUwMTIS1&b=2&j=NzAzNjU4MzUzS0&mt=1&rt=0
into your browser
Time for a Spring Makeover
Free Large Candle
When you Buy One—Any Fragrance, Every Style
Use Code SWEETONE
See Coupon Below
To shop now, copy and paste:
http://links.mkt1917.com/ctt?kn=39&ms=MTI3OTc4MDgS1&r=Mzc1MTMwMDUwMTIS1&b=2&j=NzAzNjU4MzUzS0&mt=1&rt=0
into your browser
Decorate with Smiles
To shop now, copy and paste:
http://links.mkt1917.com/ctt?kn=3&ms=MTI3OTc4MDgS1&r=Mzc1MTMwMDUwMTIS1&b=2&j=NzAzNjU4MzUzS0&mt=1&rt=0
into your browser


Terry Bogard Is Available In Super Smash Bros. Ultimate Right Now
Smash's new king of fighters
by Ryan CraddockUpdate: It appears that Terry is available in the game as we speak. Enjoy!
Original Article: The newest addition to the Super Smash Bros. Ultimate roster, Terry Bogard, will join the battle today - 6th November - it has been confirmed.
The news comes from a presentation hosted by series director Masahiro Sakurai, which aired earlier today. Alongside the fighter, players who purchase the Terry DLC will also receive a brand new stage - the King of Fighters Stadium - 50 new pieces of music from a number of franchises, and a new Spirit Board.
Terry is the fourth fighter to be released as part of the game's Fighters Pass, which has also added Joker, Hero, and Banjo-Kazooie up until this point. The fifth and final character to be included in this pass has still not been revealed, although it has already been confirmed that the mystery character will be playable by February next year.
Excited to get stuck in as Terry? Let us know if you'll be trying him out with a comment below.


Blockchain Tutorial
Some Definitions
Blockchain
- A blockchain is a distributed database.
- A blockchain maintains a continuously-growing list of ordered records called blocks.
- Each block contains a timestamp and a link to a previous block.
- Once recorded, the data in a block cannot be altered retroactively. (By design blockchains are inherently resistant to modification of the data.)
Blockchains are secure by design and an example of a distributed computing system with high byzantine fault tolerance. Decentralised consensus can therefore be achieved with a blockchain. This makes blockchains suitable for the recording of events, title, medical records and other records management activities, identity management, transaction processing and proving provenance. This offers the potential of mass disintermediation and vast repercussions for how global trade is conducted.
The first blockchain was conceptualised by Satoshi Nakamoto in 2008 and implemented the following year as a core component of the digital currency bitcoin, where it serves as the public ledger for all transactions. Through the use of a peer-to-peer network and a distributed timestamping server, a blockchain database is managed autonomously. The invention of the blockchain for bitcoin made it the first digital currency to solve the double spending problem, without the use of a trusted authority or central server. The bitcoin design has been the inspiration for other applications.
Double Spending
byzantine fault tolerance
merkle
trie
MARKET CAP
HASH RATE


My name is Laura. I'm 25 years old and recently relocated from London to Seattle during the pandemic.
My Background
Bachelor's Degree in Communication with a minor in Spanish and Film from the University of Massachusetts, Amherst
Master's Degree in Popular Music from Goldsmiths College at the University of London
Strong background in leadership with 5 years as a resident assistant and counselor for students aged 14 to 30 during the semester and over summer breaks in the US and UK
Current Washington Service Corps member serving as Program Coordinator for an after-school non-profit that brings low cost music education to students in Seattle's Central District called Seattle Music Partners
Former music production assistant to Grammy-winning dance producer, Riton in London, UK
Practicing musician since childhood with a background in classical piano and current instrumental studies in guitar, bass and drums
Fluent in Spanish since childhood with a university focus in Spanish reading, writing and linguistics


|
MatrixEngine
|
A void object with a position. More...
#include <object.h>
Public Member Functions | |
| object (const int &start_x, const int &start_y) | |
| virtual int | get_x () |
| returns x More... | |
| virtual int | get_y () |
| returns y More... | |
| virtual void | set_x (int u_x) |
| sets x More... | |
| virtual void | set_y (int u_y) |
| sets y More... | |
| void | set_pos (int x, int y) |
| Set position to given coordinates. More... | |
| void | move_up () |
| Subtracts one from x. More... | |
| void | move_down () |
| Adds Sone from x. More... | |
| void | move_left () |
| Subtracts one from y. More... | |
| void | move_right () |
| Adds one from y. More... | |
Protected Attributes | |
| xy | posXY |
| position of object More... | |
A void object with a position.
A void object with a position, an object on its own is invisable inside a frame because it's a void.
|
inlinevirtual |
returns x
returns x position of the object
|
inlinevirtual |
returns y
returns y position of the object
| void object::move_down | ( | ) |
Adds Sone from x.
Moves the object down by one unit adding one to the x position
| void object::move_left | ( | ) |
Subtracts one from y.
Moves the object left by one unit subtracting one to the y position
| void object::move_right | ( | ) |
Adds one from y.
Moves the object right by one unit by adding one to the y position
| void object::move_up | ( | ) |
Subtracts one from x.
Moves the object up by one unit subtracting one to the x position
|
inline |
Set position to given coordinates.
This function sets the position of the object to the given x, y coordinates
|
inlinevirtual |
sets x
sets x position of the object
|
inlinevirtual |
sets y
sets y position of the objects
|
protected |
position of object
x and y position of an object


Since Litecoin blocks are 4 times faster than Bitcoin’s, the network can handle a sudden decrease in hashrate much better.
If 75% of hashrate disappears overnight, Litecoin just acts like Bitcoin for 2 wks (10 mins blks) and then diff retargets and everything is back to...


Wrote my first mobile application
Today I wrote my first mobile application. It was great! I had huge amounts of fun, it was a lot easier than I expected, and I was so happy I spent the rest of the day celebrating. Today I wrote my first mobile application. It was great! I had huge amounts of fun, it was a lot easier than I expected, and I was so happy I spent the rest of the day celebrating. Today I wrote my first mobile application. It was great! I had huge amounts of fun, it was a lot easier than I expected, and I was so happy I spent the rest of the day celebrating. Today I wrote my first mobile application. It was great! I had huge amounts of fun, it was a lot easier than I expected, and I was so happy I spent the rest of the day celebrating. Today I wrote my first mobile application. It was great! I had huge amounts of fun, it was a lot easier than I expected, and I was so happy I spent the rest of the day celebrating.


Hi, anyone know why I'm getting this and am unable to start DUCKS?
2018-12-09 09:53:06 ERROR: AcceptToMemoryPool: tx inputs not found
[CFEKLAMEDUCKS] ABORTING - CFEKLAMEDUCKS has no network connections, Help Human!
CFEKLAMEDUCKS server stopping
Something went wrong, please check error messages above requiring human help and manually rectify them before starting iguana!


Upload Image and Enter object that you want to detect
Enter class name
See classes supported
Predict
Download
Clear


Heading 101
Hello there, awesome person!
Latest Mac-related news
Smartphones
A really good anime site


Novice Individual
Early Bird
(NUS/Public)
$16.20/$18
Normal
(NUS/Public)
$18/$20
Sprint Individual
Early Bird
(NUS/Public)
$16.20/$18
Normal
(NUS/Public)
$18/$20
Power Duo Race
Sign up to find out about the missions and race route awaiting you! Do take note that you do not have to run and swim consecutively.
Location: Vicinity of National Stadium
Early Bird
(NUS/Public)
$32.40/$36
Normal
(NUS/Public)
$36/$40
Finisher Shirt
(Upon Registration)
Race Singlet
(Purchase Upon Registration)


Battery Status API
Battery Status API
charging
chargingTime
dischargingTime
battery level
promise status
number of updates


Why does working with
AWS
Simple, intuitive, and safe AWS
Knowledge Base - Short videos showcasing our utilities
How do I...?
View My Templates
without emailing it to yourself!
Test My templates
right here in the browser!
View My Email Stats
And save $1250/month!
Tools for AWS SES®
View Templates
View your email Templates in the browser
Test a Template
Dry run a template. See how it looks in the browser with real data
Unlimited email IDs
Get unlimited email ids on your own domain...like a private Mailinator.
Contact us using the form below.
This service is not FREE!
SAFE, FUNCTIONAL
Don't let the unusable AWS SES
Other SES functions
Lorem ipsum buddy
Update a Template
Update a template right here in the browser.
Frequently Asked Questions
Why did you build this?
In my day job, I help manage a startup's AWS infrastructure.
While I want to have my non-tech colleagues do things on their own, I find that that AWS's web interface is basically impossible to safely navigate. At times, the AWS web interface has limited functionality.
For example, AWS's Simple Email Service does not have a place where you can see your email templates in the browser. You have to download the template, then open it in your browser as a file://
. Talk about annoying.
Can I request a specific utility for my team?
Sure. You can request a UI by emailing us. I'll build the more popular ones.
How secure are my keys?
As secure as the device you use it on. Let me explain.
This entire website is serverless. I serve it from an S3 bucket so there is no server as such to log your data. I use the AWS javascript sdk to directly connect to AWS without any intermediate hops to perform actions on your behalf.
So, if your browser is safe, e.g., you are not a public workstation, your AWS credentials are also absolutely safe. Here's our privacy policy.
Can I duplicate this?
Of course!
My source code is hosted on Github here. Just clone the repo, run http-server .
(or any such webserver for static files) on the command line and you'll be good to go.
Can I contribute?
Of course!
Check out the issues page on my Github for this project and send me a PR for any issue that you can help with.
Why is the website called Zeer0?
Zeer0 because it matches the number of hassles you will face in using these utilities!
© 2020 Zeer0.com.


This tool retrieves data from NASA's Near Earth Object Feed and displays
data for objects which are making their closest approach to Earth on the date selected.
Names of objects are provided if they are available, and the object's provisional
designation is indicated in parentheses. Each object is linked to the JPL Solar System
Dynamics Small-Body Database.
Note that this data is not necessarily complete or accurate. More NEOs remain unobserved
or untracked.
For more info see
Near Earth Object Article on Wikipedia


One of the most exciting features introduced in ES6 is generators. Their primary use case is in representing lazy (possibly infinite) sequences. For example, the following function returns the first n positive integers.
function count(n){
var res = []
for (var x = 0; x < n; x++) {
res.push(x)
}
return res
}
for (var x of count(5)) {
console.log(x)
}
We can write a very similar function using generators, that returns all the positive integers.
function* count(){
for (var x = 0; true; x++) {
yield x
}
}
for (var x of count()) {
console.log(x)
}
What's actually going on here, is that the count
function is being lazily evaluated,
so it pauses at each yield
and waits until another value is asked for. This means that
the for/of loop will execute forever, continually getting the next integer in an infinite list.
The reason this is so exciting, is that we can exploit the ability to pause a function in order to help us write asynchronous code. Specifically, this will allow us to do asynchronous things inside our existing control flow structures, such as loops, conditionals and try/catch blocks.
What generators do not do is give us a way of representing the result of an asynchronous operation. For that, we need a promise.
The goal of this article is to teach you to be able to write code like:
var login = async(function* (username, password, session) {
var user = yield getUser(username);
var hash = yield crypto.hashAsync(password + user.salt);
if (user.hash !== hash) {
throw new Error('Incorrect password');
}
session.setUser(user);
});
Here the code reads just like it would if it were synchronous, but is in fact doing asynchronous
work at each of the yield
keywords. The result of calling the login
function would
be a promise.
As you saw in the introduction, we can pause to wait for a promise using the yield
keyword.
What we need now is a way to get fine control over that generator function so as to have it start
again once the promise completes. Fortunately, it's possible to step through a generator function via
the .next
method.
function* demo() {
var res = yield 10;
assert(res === 32);
return 42;
}
var d = demo();
var resA = d.next();
// => {value: 10, done: false}
var resB = d.next(32);
// => {value: 42, done: true}
//if we call d.next() again it throws an error
What's happening here is that we call d.next()
once to get it to the yield
,
and then when we call d.next()
a second time, we give it a value that is the result
of the yield
expression. The function can then move on to the return
statement
to return a final result.
We can use this, by calling .next(result)
to signal that a promise has been fulfilled
with result.
We also need a way to represent a promise that's been yielded being rejected. We can use the
.throw(error)
method on the generator to do this.
var sentinel = new Error('foo');
function* demo() {
try {
yield 10;
} catch (ex) {
assert(ex === sentinel);
}
}
var d = demo();
d.next();
// => {value: 10, done: false}
d.throw(sentinel);
Like before, we call d.next()
to get to the first yield
keyword. We can then
signal rejection using d.throw(error)
, which causes the generator to act as though
yield
throw an error. In our example, this will trigger the catch
block.
Putting all of this together, we just have to keep manually moving the generator forwards with the results of any promises it has yielded. We can do that using a simple function like this one:
function async(makeGenerator){
return function () {
var generator = makeGenerator.apply(this, arguments);
function handle(result){
// result => { done: [Boolean], value: [Object] }
if (result.done) return Promise.resolve(result.value);
return Promise.resolve(result.value).then(function (res){
return handle(generator.next(res));
}, function (err){
return handle(generator.throw(err));
});
}
try {
return handle(generator.next());
} catch (ex) {
return Promise.reject(ex);
}
}
}
Note how we use Promise.resolve
to ensure we are always dealing with well behaved
promises and we use Promise.reject
along with a try/catch block to ensure that
synchronous errors are always converted into asynchronous errors.


---
layout: archive
title: Lean Prover Zulip Chat Archive
permalink: 113488general/21022TermrewritingandPLtheory.html
---
The archive URL format has changed. Please find this page at:
https://leanprover-community.github.io/archive/stream/113488-general/topic/Term.20rewriting.20and.20PL.20theory.html


2 writes to _variables
System.Management.Automation (2)
engine\interpreter\ControlFlowInstructions.cs (2)
707
_variables
= locals.CopyLocals();
777
_variables
= null;
1 reference to _variables
System.Management.Automation (1)
engine\interpreter\ControlFlowInstructions.cs (1)
769
var compiler = new LoopCompiler(_loop, frame.Interpreter.LabelMapping,
_variables
, _closureVariables, _instructionIndex, _loopEnd);


---
title: projects
permalink: "/projects/index.html"
layout: projects
---
resume |
home
Conversion Master is the ultimate comprehensive resource for unit conversion. Quite possibly the simplest, fastest unit converter on the market. 100's of units to convert between; from engineering units to daily units. Thousands of possible conversions. Conversions happen instantaneously as you type in the number. No need to press Enter or Next. No scrolling through long lists to find the proper radio buttons to select. A super fast and intelligent UI to get you the information you need as fast as possible. All conversions are visible and evaluated in real time. The most succinct Unit Conversion app on the Google Play. Nothing to get in the way.


|
Plant-o-Matic
|
Table of Contents
Automated plant care and monitoring system using Raspberry Pi Model 3 B+
Explore the docs »
View Demo · Report Bug or Request a Feature
<details open="open">
</details>
Plant-o-Matic is an automated plant care and monitoring system implemented on Raspberry Pi Model 3 B+ with the help of C++, nginx and FastCGI.
For some people plants are parts of their families and taking care of their plant is as crucial as for other people to take care of their pets. For others, they are something they keep forgetting about because of the busy schedule or heaps of thoughts.If you belong to the latter category, this project is for you! With it's help, it is possible not just to grow a plant, but also monitor it's state and other related data.
System senses the soil moisture and the surrounding temperature and humidity. With the help of ultrasonic sensor, it is possible to observe the water level of your home reservoir to see if the water is enough to feed your plant while you are out of home. If the soil is gets dry and there is appropriate water level, water pump will automatically start and irrigate the plant.
Data monitoring is done in a web application, which is hosted on the Raspberry Pi.
Before purchasing any device and starting to work with it, it is important to check its datasheet/manual. For this project, we've collected this information for each device. You can check it in the Hardware folder.
The interconnection diagram:
Before downloading the project, check if the following prerequisites are present on your Raspberry Pi:
To install:
To install:
Reload the configuration file, if changes were made:
If not, please visit our wiki page for detailed instructions.
To built:
To run: Run it with the command:
To test:
Start Plant Plant
in the background with:
which creates sockets under /tmp/soilsocket
, /tmp/tempsocket
,/tmp/humsocket
, /tmp/ultrasonic
to communicate with the fastcgi server.
See the open issues for a list of proposed features (and known issues).
Contributions are what make the open source community such an amazing place to be learn, inspire, and create. Any contributions you make are greatly appreciated.
git checkout -b feature/AmazingFeature
)git commit -m 'Add some AmazingFeature'
)git push origin feature/AmazingFeature
)Distributed under the MIT License. See LICENSE for more information.
Project Link: https://github.com/atuatohu/Plant-o-Matic


Training provider interface
esfa prototype
How to use this prototype
Visit the prototype link and use the login credentials in the first instance.
Prototype link
https://esfs-prototype.herokuapp.com/Login credentials
- Username
- apprentice
- Password
- james


As Donald Knuth once said, "Premature optimization is the root of all evil in programming." However, although optimization matters less often than programmers think, it does matter; and this was one of the minority cases where it matters.
Profiling proved that JDOM was spending a significant chunk of time performing verification. Every name character required several checks, and JDOM recognized a nonname character only after checking it first against every possible name character. Consequently, the number of checks increased in direct proportion to the code point value. The project maintainers were beginning to grumble that maybe verification wasn't so important after all, and they might make it optional or ditch it entirely. Now, personally, I'm not willing to compromise correctness in the name of faster code, but it was apparent that the decision was going to be taken out of my hands if someone didn't do something. Fortunately, Jason Hunter did.
Hunter restructured my naïve code in a very clever way, shown in Example 5-5. Previously, even the common case where a character was legal required over 100 tests for each of the possible ranges of illegal characters. Hunter noticed that we could return a true value much sooner if we recognized both legal and illegal characters. This is especially beneficial in the common case where all names and content are ASCII, because these characters are the first ones we test.
The earlier implementation checked a character against all possible digits, including such unlikely things as é and Φ, before deciding a character wasn't a digit. The newer approach could determine more quickly that a character wasn't a valid digit. Similar and even more significant improvements were made to the checks for letters, extenders, and combining characters.
This didn't eliminate the time spent on verification, but it did reduce it enough that the project maintainers were appeased, at least for the case of element names. PCDATA verification still wasn't in the build, but that wasn't quite as big a problem.


Pairing Feedback
The business of people
May 31, 2015
Overall I find pairing with others to solve challenges is a challenge in and of itself. I am often anxious and worried during the pairing session thinking about if I'm being overbearing or if I'm not contributing enough or how best to disagree and get my point across. My mind is too clouded with thoughts like that to really study and digest the exercise at hand. More than once, my partner and I would spend over 30 minutes troubleshooting in vain together before giving up for a short break. During the break, I'd breathe a sigh of relief before realizing that a simple fix is actually staring at me in the face. Had my mind not been a cluster of self-conscious thoughts, we may have been finished with the challenge 30 minutes ago.
That being said, there are advantages to pairing. I have learned much about working with others and facilitating pairing sessions. Surprisingly, I come from a consultant background and working with others was a big part of my day job. However, through these pairing sessions, I've realized that I still have a long ways to go in terms of communicating my thoughts and actively listening to others while keeping my mind clear.
I appreciate all the feedback I received from the pairing sessions. It was helpful to see where I can improve on and I'd certainly like to make sure I show respect and consideration to all my partner at all times, not just most of the time. Out of all the metrics we are measured by, that is the one I care about the most. Like I mentioned earlier, I do not want to come off as overbearing and controlling. The other metric that I especially care about is benefiting the team/pair culturally. To work on this aspect of my pairing, I plan to be positive and inspiring in the face of even the most difficult exercises. If I find myself getting frustrated, I plan to take a step back and ask for a short break before returning ready with a conducive attitude.
When asked to write feedback for others, I find that I have an easier time writing positive experiences about the pairing than I do writing constructive criticisms. Perhaps this is just part of human nature to avoid conflicts. Though I've been working on changing my mindset so that I can be helpful to others in letting them know my experiences with them.
Latest Tweet
tweet tweet
Social
FB Twitter GitHub LinkedIn Google+


Across: 5. Spot dead fruit (6) 8. Looked around, very quietly, then scattered! (8) 9. Present show to a French daughter (7) 10. I am after study material (5) 11. Little drop may not be enough! (9) 13. Open up, or secure, access (8) 14. Bob, record a new catchphrase (6) 17. Bath with Townsend's secretary (3) 19. Two elders hold up sign (3) 20. Models embrace in picture (6) 23. Tries to lure wartime girls outside (8) 26. Reprimand one after having made electronic tag back-to-front! (9) 28,16dn. Cheap choice of music? (5 3 1 4) 29. Leader has a last trip by the sea (7) 30. Dog is exercising cattle at the bottom, right? (8) 31. Stunned by a great host attacking six Turkish capitals! (6) Down: 1. Reportedly spotted the woman on the web? (6) 2. Chaps run around at home to find vegetable (7) 3. Pay back for rotten mulberries left outside (9) 4. Holiday setback? (6) 5. Former partner sorted out external sugar supplier (8) 6. Quietly cover over conclusive evidence (5) 7. See terrible tangle in home of British Lions (8) 12. Two males may be on edge (3) 15. See female smile with knight (9) 16. See 28 18. Expecting one to leave parenting organisation (8) 21. About time one went inside with Felix (3) 22. This may hold you down and give you unwanted information! (7) 24. Casual worker returns in a rage! (6) 25. Deigns to set out as directed (6) 27. Opera is a version of Cats with nothing added! (5)


Ladies' Code's Sojung shares her thoughts on the passing of members EunB and Rise
by sl278Ladies' Code's Sojung revealed her thoughts on members EunB and Rise who tragically passed away in a car accident a few years ago.
Sojung appeared on the November 11 broadcast of Channel A's 'Eye Contact' where she revealed thoughts that she previously wasn't able to talk about before.
She stated that after the car accident that took the lives of her two fellow members on her birthday, her birthday doesn't seem like her birthday anymore. She continued stating: "This isn't a day where people congratulate me. I went to visit my unni's and to have a birthday party later on that same day seems weird. Afterwards was hard. It was hard to do anything and I thought that I shouldn't do anything. My birthday is a sad day. "
She continued, stating: "At first, it didn't seem real. It just seemed like they were away on a long vacation to somewhere far away. We had a hard time. They appeared in the other member's dreams but not mine. I think it was because I couldn't accept reality."


To prevent access by unauthorized entities, please enter a username and password. Remember this password well, you will need it in the future if you are to change any important setting.


Contact:
Sujoy Kumar Sikdar
Amos Eaton AE 204
Rensselaer Polytechnic Institute
110, 8th Street, Troy, NY 12180
[CV] [Google Scholar] [Linkedin]
▪ 2012 - 2018, Doctor of Philosophy, Computer Science, Rensselaer Polytechnic Institute, Troy, NY.
Thesis: Optimal Multi-Attribute Decision Making in Social Choice Problems.
Advisers: Prof. Lirong Xia and Prof. Sibel Adalı.
▪ 2012 - 2015, Master of Science, Computer Science, Rensselaer Polytechnic Institute, Troy, NY.
Thesis: Towards an Understanding of Information Credibility on Online Social Networks.
Advisers: Prof. Sibel Adalı.
▪ 2005 - 2009, Bachelor of Engineering, Information Technology, Manipal Institute of Technology, Manipal, India.
Computational Social Choice, Mechanism Design, Human Decision-Making, Trust and Credibility on Social Networks, Information Aggregation, Artificial Intelligence, Algorithm Design, Machine Learning.
I am interested in (optimal) decision making over multiple attributes or issues in social and individual choice which includes the following problems:
Multi-Resource Allocation: Fair and Efficient allocation of mutiple types of items in Allocation and Exchange Markets.
Combinatorial voting: Making a group decision over multiple issues.
Human Behavior on Social Networks: Modeling human choices and decision-making in real data.
Please find a more detailed description of my research activities below.
My MS and PhD theses concentrated on decision making problems in multi-attribute domains through theory as well as real-world applications. I approach these problems from two directions:
(Direction 1) The social choice problem of Making Optimal Decisions under Preferences.
Multi-Resource Allocation: Allocation and Exchange Markets involving items of mulitple types.
▪ We provide the first positive results in mechanism design for multi-type exchange markets. In exchange markets, the resources are initially owned by the agents and the goal is to find an optimal and stable redistribution of resources, while ensuring participation. Participation is a particularly important property for a centralized mechanism when parallel markets are undesirable such as in paired organ donation, assigning students to courses of multiple types to satisfy graduation requirements, allocation of dorm rooms and other facilities in a university, and reassigning computational resources in a cloud computing platform. Our mechanism satisfies strict-core selection, non-bossiness and a restricted version of strategyproofness under some natural structural assumptions on agents' combinatorial preferences over bundles.
▪ In the allocation problem, the goal is to allocate bundles of resources given agents' preferences. We characterize sequential mechanisms, study their social choice and computational properties and provide rank efficiency bounds when agents are strategic.  An example is the problem of assigning a research paper and time slot to students in a seminar course given their preferences.
Combinatorial voting: Making a group decision over multiple issues such as the decision on multiple referenda or deciding a menu for a dinner party. We provide the first framework to reason about optimal decisions when agents' preferences are represented by CP and PCP-nets with full generality. CP-nets are a popular language to represent agents' combinatorial preferences over multiple issues allowing agents to specify conditional preferential dependencies on the values for different types. Our framework leads to a natural optimization objective while previous works imposed various restrictions on agents' preference structures. A new class of voting rules under our framework allows the aggregation of profiles of CP-net preferences without any assumptions on the structure of preferences.
(Direction 2) Learning Preferences from real world Data.
Human Behavior on Social Networks: Modeling human choices and decision-making through voting and discussion behavior on social networks using data mining, NLP, machine learning, and learning-to-rank techniques. We provide new insights into what drives conversations on social content sharing and discussion platforms such as Reddit using models that learn to rank comments. We develop natural language features to model the factors affecting voting behavior. Our supervised machine learning methods rank the comments with high precision and are human interpretable. We show that our methods are effective across a diverse set of communities that deal with topics as diverse as question answering communities dealing with science and history to communities that discuss news and politics. A post hoc analysis reveals new insights into factors affecting users' voting behavior.
Human Choices in Question Answering: In collaboration with social psychologists, we develop models inspired by psychology literature to understand why certain answers are more popular in a dataset obtained in a controlled environment.
Computational Social Choice, Game Theory, Machine Learning, Analysis of Algorithms, Approximation Algorithms, Intro. to Computational Finance, Distributed Computing Over the Internet, Frontiers of Network Science, Mathematical Statistics, Linear Programming.


{% from "macros" import img, blogimg %} {% set p = post %}
{% extends "templates/post.html" %} {% block post %} {% filter markdown %}
These notes are based on the book [Contemporary Abstract Algebra 7th ed][0].
[0]: http://www.amazon.com/Contemporary-Abstract-Algebra-Joseph-Gallian/dp/0547165099
Binary operations
-----------------
> Let G be a set. A binary operation on G is a function that assigns each
ordered pair of elements of G an element of G.
In other words, a binary operation on G is a function `f` such that `f(a,b)=c`
with a,b,c as elements of G.
### Examples
Addition, subtraction, and multiplication are all binary operations on the set
of integers. These three operations are in fact functions! You can define a
function `+` from the set of integers *to* the set of integers defined by
+(a,b)=the addition of a and b
We can then use infix notation instead of the function notation, and we arrive
with `a+b`.
Note that division is **not** a binary operation on the set of integers. Why
is that? Consider `1` divided by `3`. `1` and `3` are both integers, but `1/3`
is not.
{{blogimg(g,p, "img1.png")|safe}}
Group
-----
> Let G be a set together with a binary operation * (meaning a*b is an
element of G for all a,b in G). G is called a group under * if the following
three properties are all met:
{{blogimg(g,p, "img2.png")|safe}}
### Closure
> If * is a binary operation on G, we say G is "closed" under *, or G has
"closure" under *
### Examples
Prove the integers under addition is a group.
{{blogimg(g,p, "img3.png")|safe}}
Since the definition of a group explicitly says that groups deal with binary
operations, we must first verify that the operation is *actually* closed.
In this case, there wasn't much to show since the addition of integers is
closed and associative under the integers by definition. However, for more
complex functions, the proof is not always so easy.
{{blogimg(g,p, "img4.png")|safe}}
Elementary Properties of Groups
-------------------------------
There are some properties that all groups share, no matter what form their
elements are in or how complex/simple the operation on that group is.
### Thm 2.1: Uniqueness of the Identity
> In a group G, there is only one identity element
#### Proof strategy: Showing uniqueness
A *very* common strategy in proving the uniqueness of some value is to suppose
to the contrary that there are actually two values. You then maneuver your way
through to show that the two values you chose are actually equal, meaning
there really is just one unique value. In this proof, we will suppose there
are two identities, show that they were equal to one another, which lets us
conclude that there really is only one identity.
{{blogimg(g,p, "img5.png")|safe}}
So now we can safely refer to an identify of a group as **the** identity.
### Thm 2.2: Cancellation
> In a group G, the right and left cancellation laws hold; ba=ca implies b=c,
and abc=ac implies b=c.
{{blogimg(g,p, "img6.png")|safe}}
We have to take special note to multiply equations on the same side because
groups do not necessarily have the property of being commutative under their
operation. That means there is no guarantee `ab` = `ba`, so in order to
preserve equality in our arithmetic, we must multiply on the same sides of
both sides of the equation.
### Thm 2.3: Uniqueness of Inverses
> For each element a in a group G, there is a unique element b in G such that
ab=ba=e.
In our initial definition, we stated that there must exist *an* element `b` in
G such that `ab` = `e`. However, now we're going to show that this inverse is
unique.
#### Reminder: Proving uniqueness
Recall that a common proof strategy to showing uniqueness of a value is
suppose that there are two, and conclude they are the same. In this case,
we're trying to show that there is only one inverse of a. Thus, we start out
by supposing a has two inverses, and then we work to show they are in fact the
same.
{{blogimg(g,p, "img7.png")|safe}}
### Some notation
Now that we have proven the uniqueness of inverses, we can now safely denote
the inverse of the element a in the group G by a-1.
When `n` is a positive integer, an represents n factors of
`aa...a`. Non integer exponents are not defined for this group notation.
(a.5 doesn't mean anything and should thus be avoided).
When `n` is negative, gn can be expressed as
(g-1)|n|. For example, g-3 =
(g-1)3.
g0 is defined as the identity `e`.
Some familiar laws of exponents hold for groups, such as
* gmn = gm+n
* (gm)n = gmn
Not all laws hold, though. For example, it's not guaranteed that
(ab)n equals anbn.
Groups operations are usually represented with a multiplicative notation. Make
sure to not get confused when dealing with additive operations!
### Thm 2.4: Socks-shoes property
> For group elements a and b, (ab)-1=b-1a-1
#### Proof strategy: Showing equality of elements within groups
Sometimes you want to show that elements `a` and `b` of a group G are equal.
In the event you know the values, it's pretty straight forward to just compare
them. However, in this case, we know very little about `a` and `b`, but we can
prove their equality using our knowledge of groups. We recently proved that
the inverse of an element `g` in G is unique. This means if `ga=e` and `gb=e`,
then `a`=`b`. We use this fact to prove theorem 2.4.
{{blogimg(g,p, "img8.png")|safe}}
{% endfilter %} {% endblock post %}