[gecode-users] Adding constraints to model in <RBS>: is there any example code?
Dirk Obermann
dirk.obermann67 at gmail.com
Tue May 9 20:43:04 CEST 2017
Hi Christian,
sorry for taking long to respond. I read the manual and tried to modify the
engines to do what I wanted. Unfortunately, I was not succesfull...
My first attempt was to run BAB until completion with the long steps
(adding chunks of constraints in the constrain() function). I was then
hoping that I should be able to modify the last solution returned by BAB
(by setting a parameter in the corresponding object,
lastSolution->setLargeChunks(false), to influence the behavior of the
constrain function in the future), and create and run a new BAB with this
solution object as initial object. (something like BAB<...> e(lastSolution,
options) ). Although it does run, I get the feeling that it starts the
search from the beginning and does not benefit from the search done so far.
I then tried to understand how to modify the parallel engine code, but it
was beyond my capabilities...
Thanks,
Dirk
On Tue, Apr 18, 2017 at 1:52 PM, Christian Schulte <cschulte at kth.se> wrote:
> Hi Dirk,
>
>
>
> Yes, I see your motivation but the Gecode engines cannot do that. Have you
> ever had a look at the part in MPG about search? Building a BAB engine with
> this additional feature might be not that hard…
>
>
>
> Good luck
>
> Christian
>
>
>
> --
>
> Christian Schulte, www.gecode.org/~schulte
>
> Professor of Computer Science, KTH, cschulte at kth.se
>
> Expert Researcher, RISE SICS, christian.schulte at ri.se
>
>
>
> *From:* Dirk Obermann [mailto:dirk.obermann67 at gmail.com]
> *Sent:* Wednesday, April 12, 2017 22:28
> *To:* cschulte at kth.se
> *Cc:* users at gecode.org
> *Subject:* Re: [gecode-users] Adding constraints to model in <RBS>: is
> there any example code?
>
>
>
> Thanks, Christian.
>
>
>
> You were, of course, correct. BAB does the job and my code is now much
> more elegant than before. It also works well to combine with RBS.
>
>
>
> However, my earlier code was sometimes faster. The reason is that I could
> take "large steps", adding constraints in chunks until the search failed. I
> could then go back to the last feasible model and add constraints one by
> one instead of in chunks.
>
> Is something similar possible in the gecode search engines? What I would
> like do is the following: I run BAB until fail, and then "reset the state
> of the engine" to where it was when it produced the last feasible solution
> ("before my last call to the constrain function", so to speak). I would
> then re-run the search from there (with another behavior of the constrain
> function).
>
> Thanks,
>
> Dirk
>
>
>
> On Tue, Apr 11, 2017 at 1:49 PM, Christian Schulte <cschulte at kth.se>
> wrote:
>
> Hi,
>
>
>
> First, I am not so sure that your idea works in principle: you say that
> the problem is that you spend a lot of time to find a first feasible
> solution, especially after adding additional constraints. However, that
> would not change with restarts: after all, you would restart the search and
> would have to do the same search in order to find the first feasible
> solution. The only benefit I could see is adding no-goods from restarts.
>
>
>
> Anyway, what you want to do (I guess) is that you accumulate additional
> constraints which each restart. This you can only do by adding constraints
> to the master (remember, the slave will always be initialized fresh from
> the master for each restart). LNS is different as you want try different
> constraints each time you restart, hence you have to do it on the slave.
>
>
>
> Hence, you will have to reimplement the master function, there you just
> add the additional constraints.
>
>
>
> Have you thought about using BAB? There, each time you find a solution you
> can add new constraints based on that solution _*without*_ restarting
> search. Sounds more like it to me.
>
>
>
> Cheers
>
> Christian
>
>
>
> --
>
> Christian Schulte, www.gecode.org/~schulte
>
> Professor of Computer Science, KTH, cschulte at kth.se
>
> Expert Researcher, RISE SICS, christian.schulte at ri.se
>
>
>
> *From:* users-bounces at gecode.org [mailto:users-bounces at gecode.org] *On
> Behalf Of *Dirk Obermann
> *Sent:* Tuesday, April 11, 2017 13:34
> *To:* users at gecode.org
> *Subject:* [gecode-users] Adding constraints to model in <RBS>: is there
> any example code?
>
>
>
> Hello -
>
>
>
> I am trying to do program up a search engine that performs sequential
> refinement by adding more and more constraints to a model. In the first
> run, I am happy with a solution at all, but then I want to add increasingly
> complex constraints until there is no more solution (or the search engine
> times out).
>
>
>
> Now, I first run a model with a single constraint. If DFS can find a
> solution, then I run a completely new model with two constraints and from
> scratch. If this model is feasible, then I run the model with three
> constraints, etc.
>
>
>
> In principle, this solution works, but it is a very inefficient: a lot of
> time is spent generating the first feasible solution when restarting the
> search (especially as the problem becomes more constrained).
>
>
>
> It seems to me that this should be doable with RBS or a variation of the
> LDS engine, as described in the MPG. But there are very few examples to
> follow (the closest I found was this question posted on stack overflow
> http://stackoverflow.com/questions/34182681/how-to-
> change-the-variable-value-ordering-in-gecodes-restart-based-search but
> unfortunately it does not contain any answer). I simply cannot understand
> how to do it right. In particular, where do I post additional constraint on
> the model (in the master space, the slave space or elsewhere)?
>
>
>
> Any leads on how to do it, or links to code that adds constraints or
> changes branching order in RBS would be appreciated!
>
>
>
> Cheers,
>
>
>
> Dirk
>
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.gecode.org/pipermail/users/attachments/20170509/84637704/attachment.html>
More information about the users
mailing list


"You might belong in Hufflepuff,
Where they are just and loyal,
Those patient Hufflepuffs are true,
And unafraid of toil."
- The Sorting Hat
Helga Hufflepuff
Helga Hufflepuff (fl. c. 993) was a Welsh witch and was one of the four founders of Hogwarts School of Witchcraft and Wizardry. While the other founders chose to have special students, she accepted them all without preference, but the students of her house are described as loyal and hard-working. Helga's portrait remained at Hogwarts by at least the 1980s.


The breakfast package performs multiple change-point detection in data sequences, or sequence segmentation, using computationally efficient multiscale methods. This version of the package implements the "Tail-Greedy Unbalanced Haar", "Wild Binary Segmentation" and "Adaptive Wild Binary Segmentation" change-point detection and segmentation methodologies. To start with, see the function segment.mean.
| Version: | 1.0.0 |
| Depends: | R (≥ 3.4.0) |
| Imports: | plyr |
| Published: | 2017-09-28 |
| Author: | Piotr Fryzlewicz [aut, cre] |
| Maintainer: | Piotr Fryzlewicz <p.fryzlewicz at lse.ac.uk> |
| License: | GPL-2 | GPL-3 [expanded from: GPL] |
| NeedsCompilation: | no |
| CRAN checks: | breakfast results |
| Reference manual: | breakfast.pdf |
| Package source: | breakfast_1.0.0.tar.gz |
| Windows binaries: | r-devel: breakfast_1.0.0.zip, r-release: breakfast_1.0.0.zip, r-oldrel: breakfast_1.0.0.zip |
| OS X binaries: | r-release: breakfast_1.0.0.tgz, r-oldrel: breakfast_1.0.0.tgz |
| Old sources: | breakfast archive |
Please use the canonical form https://CRAN.R-project.org/package=breakfast to link to this page.


The String module provides functionality for encoding, escaping and formatting strings.
It may also apply a number of fixes to the built-in String
object.
Adds entries to UsefulJS.featureSupport:
Whether \u{...} escape sequences can be used.
Formats a string with placeholder fields replaced with argument values.
UsefulJS.String.sprintf(fmt[, field1[, field2 ...]])
fmt
Stringfield1 ... fieldn
String|NumberReturns: String. The formatted string
Throws: TypeError: unrecognized format code; unexpected argument type for the field.
var company = "Holding Holdings, Inc", year = (new Date()).getFullYear(), copyright = UsefulJS.String.sprintf("Copyright (C) %04d %s. All rights reserved.", year, company);
The general syntax of a sprintf format field is:
%[argno][flags][width][precision]type
Items in square brackets are optional and for some type values they may be ignored.
%ld
sequence for a long int
value. Let me put it like this: JAVASCRIPT IS NOT C! C is a strongly typed language
and the compiler cares very much about the distinction between an int
and long int. JavaScript is a weakly typed language; not only am I
unable to make the distinction but I don't even care to.| Field type | Purpose | Notes |
|---|---|---|
| %d | Signed integer | Range is ±253 - 1. Locale-aware |
| %i | 32-bit signed integer | Range is -231 to 231 - 1. Not locale-aware |
| %u | 32-bit unsigned integer | Range is 0 to 232 |
| %x / %X | Unsigned integer in hexadecimal notation | Range is the same as %u. %X uses uppercase characters and '0X' with the # flag |
| %o | Unsigned integer in octal notation | Range is the same as %u |
| %b / %B | Unsigned integer in binary notation | Range is the same as %u. %B uses uppercase '0B' with # flag |
| %f | Floating point value in decimal format | Locale-aware |
| %e / %E | Floating point value in exponential format | %E uses an uppercase 'E' for the exponent part; exponent value is a minimum of two digits |
| %c | A single character or surrogate pair | Codepoint in the range 0 to 0x10ffff |
| %s | A character string | - |
| %% | A literal '%' character | Note that x% is not a valid percentage format in certain locales |
%p
and %n
fields and I wouldn't even if I could since they're features
in search of a use case. In twenty five years I've never once used %g
which behaves like %f
or %e
depending on the magnitude
and has a funky interaction with the precision field. So that one's out too.Generally, each field in the format string consumes the next argument. You
can change this behaviour by specifying the argument number in the first slot
in the format field. The syntax is n$
where n
is the argument number. it must be a minimum of 1 since argument 0 is the format
string itself. To illustrate:
UsefulJS.String.sprintf("%1$3u %1$#04x %1$#010b", 23); // " 23 0x17 0b00010111"
Flags control the appearance of the formatted value. You can use as many of them as you like, though some may be ignored.
| Flag | Purpose | Notes |
|---|---|---|
| - | Left-align padded values | Fixed width fields are right-aligned unless this flag is set; left aligned fields ignore the '0' flag |
| + | Prefix positive numbers with '+' | Only used when the field indicates a signed value: %d, %i, %e %f |
| <SPACE> | Prefix positive numbers with 'NBSP' (non-breaking space) | Only used when the field indicates a signed value |
| 0 | Pad numeric fields with '0' characters; otherwise NBSP characters are used | - |
| # | Prefixes binary, octal and hex values with a base identifier | Hex values are prefixed with '0x', octal values with '0' and binary values with '0b'. Affects the behaviour of the width field |
| , | Group the digits in the output value (e.g. "1,000" rather than "1000") | Only used when the field is %d or %f |
The width field follows the flags and is a number that specifies the minimum width of the formatted field. Formatted values wider than this are not truncated. Field width is applied after all other formatting is complete, so precision and prefixes are taken into account when calculating how much padding is required:
UsefulJS.String.sprintf("%+7.4f", 1.0); // "+1.0000" UsefulJS.String.sprintf("%+8.4f", 1.0); // " +1.0000"
A dynamic width can be specified with the '*' character. This consumes an argument. To illustrate:
UsefulJS.String.sprintf("%*d", 2, 1); // " 1"
The width field also controls the output width with the %s field type:
UsefulJS.String.sprintf("%8s", "expand"); // " expand" UsefulJS.String.sprintf("%-8s", "expand"); // "expand "
The precision field follows the width and is a number preceded by a '.' character that specifies how many digits after the decimal point are to be displayed when used with the %f and %e field types. The default value is 6. Trailing zeroes in the output are not suppressed:
UsefulJS.String.sprintf("%f", 1); // "1.000000" UsefulJS.String.sprintf("%.2f", 1); // "1.00"
As with the width, you can specify precision dynamically with the '*' character:
UsefulJS.String.sprintf("%.*f", 2, 1); // "1.00"
When used with the %s field type, the precision value controls the output width, truncating if required:
UsefulJS.String.sprintf("%.8s", "truncated"); // "truncate"
The %d and %f fields are locale aware (that is, assuming that the
UsefulJS.Number
module is available). This means that the decimal
separator and digits for the current locale are observed:
UsefulJS.Locale.current = "fr"; UsefulJS.String.sprintf("%.*f", 2, 1); // "1,00" UsefulJS.Locale.current = "hi"; UsefulJS.String.sprintf("%.*f", 2, 1); // "१.००"
You can enable grouped output with the ',' (comma) flag to improve readability:/p>
UsefulJS.Locale.current = "en-IN"; UsefulJS.String.sprintf("%,d", 100000); // "1,00,000"
Beyond this, the formats used for numbers are fixed. If you have more complex
formatting requirements (e.g. currency or suppressing trailing zeroes), you
should format the numbers as a separate step and use %s
fields.
Here is a simple but functional internationalization framework:
var I18N = { strings : { de : { question : "Was ist das Ergebnis der Multiplikation %1$.1f von %2$.1f?", ... }, en : { question : "What do you get when you multiply %1$.1f by %2$.1f?", ... }, ... }, resolve : function(key/*, arg1, arg2, ... */) { var fmt = I18n.strings[UsefulJS.Locale.current][key]; if (!fmt) { return key; } // Get the rest of the arguments var args = Array.from(arguments); // Put the format string on the front args[0] = fmt; return UsefulJS.String.sprintf.apply(null, args); } }; UsefulJS.Locale.current = "de"; I18n.resolve("question", 6, 9); // "Was ist das Ergebnis der Multiplikation 6,0 von 9,0?"
Note the use of positional parameters %1$.1f
and %2$.1f
.
This is particularly important for %s
fields. When your stringtable
entries are translated, the word order can change very radically and there is
no way of distinguishing one %s from another when the argument order is fixed.
Specifying which arguments to use in the format string means that substitution
won't produce gobbledegook.
The functions in the
Returns its input, UTF-8 encoded.
UsefulJS.String.encode.toUtf8(s)
s
StringReturns: String
UTF-8 is a character encoding that uses a variable number of 8-bit bytes to encode a single character. The bit pattern in the first byte of the sequence says how many bytes are in an encoded sequence. UTF-8 has a number of intrinsic advantages over other character encodings:
char
data type can handle UTF-8 data.
Important values like the null terminator retain their special meanings
so that UTF-8 encoded data can be used with, for example, std::string
.No more than four bytes are required to represent any defined character. Here are some examples:
UsefulJS.String.escape.js(UsefulJS.String.encode.toUtf8("$")); // "$"; unchanged UsefulJS.String.escape.js(UsefulJS.String.encode.toUtf8("£")); // "\xc2\xa3" UsefulJS.String.escape.js(UsefulJS.String.encode.toUtf8("€")); // "\xe2\x82\xac" UsefulJS.String.escape.js(UsefulJS.String.encode.toUtf8("💩")); // "\xf0\x9f\x92\xa9"
Following the Noncharacter FAQ, noncharacter codepoints are encoded like
any other. However, codepoints that represent isolated halves of a surrogate
pair are encoded as "\xef\xbf\xbd"
, the UTF-8 encoding of U+FFFD,
the replacement character. Note that no "BOM" (byte-order mark) is emitted -
this is absolutely not needed for UTF-8. If, for some reason, the receiving
program expects one, you can prefix the encoded string with with
"\xef\xbb\xbf"
.
UTF-8 decodes its input, returning a regular String.
UsefulJS.String.encode.fromUtf8(s)
s
StringReturns: String
Valid UTF-8 sequences in the input are decoded to the corresponding codepoints. This includes sequences that decode to noncharacters. Invalid sequences are decoded to U+FFFD, the replacement character. Invalid sequences are:
Canonicalizes line-endings as "\n".
UsefulJS.String.encode.lf(s)
s
StringReturns: String
Strips carriage returns out of its argument and returns the result.
Canonicalizes line-endings as "\r\n".
UsefulJS.String.encode.crlf(s)
s
StringReturns: String
Replaces all newlines in its argument with carriage return / newline pairs. If called twice on the same string, carriage returns will not be doubled-up.
UTF-8 encoding and decoding may trivially be done using the deprecated
escape
and unescape
functions:
var s = "...", encoded = unescape(encodeURIComponent(s)), decoded = decodeURIComponent(escape(encoded));
This works because URLs must be UTF-8 encoded with individual octets
%-escaped. escape/unescape
are completely unaware of this and treat the UTF-8
byte values as individual characters.
I chose to implement my own codec for a number of reasons. The primary reason
is the dependence on deprecated functions which may stop working at any time. The
other is control over error handling; decodeURIComponent
throws on
invalid input (with, given the context, a slightly weird "Malformed URI" error) while
I prefer to replace bad sequences with a replacement character and carry on.
Functions in the UsefulJS.String.escape
namespace are used to
escape potentially problematic characters in strings before they're used in
various contexts.
Escapes a String for use in HTML
UsefulJS.String.escape.html(s)
s
StringReturns: String
This is a basic escape function, only escaping &<>'"/. It's intended
to prevent you from shooting yourself in the foot when using innerHTML
.
The better approach is to document.createTextNode
or attribute.setValue
which turn strings plain old data that will never be interpreted. The
function does not emit character entities like ®
since
these have not been required for years - simply specify a UTF-8 charset in
a <meta> element.
Escapes a String for use in JavaScript
UsefulJS.String.escape.js(s)
s
StringReturns: String
This uses a fairly paranoid escape algorithm: only ASCII alphanumeric characters
(A-Z, a-z and 0-9) are not escaped. Otherwise, codepoints below U+0100 are escaped
using the form \xHH
where 'H' is a hexadecimal digit. The escaping
of other codepoints depends on the capabilities of the browser: if the \u{H...H}
escaping style is supported, this form will be used; if not the escape sequence
will use the \uHHHH
style.
Escapes a String for use in in regular expressions
UsefulJS.String.escape.regex(s)
s
StringReturns: String
String values passed to the RegExp
constructor may need to be
escaped if you don't want certain characters to interpreted as part of the
regular expression syntax. This function backslash-escapes the following
characters: \.-[]{}()^$|+?*. Note that '/' does not need to be escaped unless
you're in the habit of constructing dynamic regexes with eval
.
The fixes for the String module implement a number of ES5/6 methods and are defined in the _string namespace of the fix options. Fixes are applied automatically apart from the padLeft and padRight options which, as library extensions, must be explicitly enabled.
String prototype methods are implemented generically so that you can apply any value to them:
String.prototype.includes.call([1,2,3,4], ",3,")
As per spec, however, they will throw a TypeError if the first argument is null or undefined.
Adds a startsWith
method to String.prototype
if
it is not implemented natively.
string.startsWith(t)
See the MDN documentation for details.
Adds an endsWith
method to String.prototype
if
it is not implemented natively.
string.endsWith(t)
See the MDN documentation for details.
Adds an includes
method to String.prototype
if
it is not implemented natively.
string.includes(t[, pos])
See the MDN documentation for details.
Adds a trim
method to String.prototype
if
it is not implemented natively.
string.trim()
See the MDN documentation for details. The pattern used for whitespace is Unicode-aware.
Adds a trimLeft
method to String.prototype
if
it is not implemented natively.
string.trimLeft()
See the MDN documentation for details.
Adds a trimRight
method to String.prototype
if
it is not implemented natively.
string.trimRight()
See the MDN documentation for details.
Adds a repeat
method to String.prototype
if
it is not implemented natively.
string.repeat(count)
See the MDN documentation for details.
Adds a padLeft
method to String.prototype
.
string.padLeft(padTo, padWith)
Adds 0 or more copies of the character in padWith
to the start of
string
so that it is at least padTo
characters long and returns
the result. If string
is already long enough, no padding is applied.
Adds a padRight
method to String.prototype
.
string.padRight(padTo, padWith)
Adds 0 or more copies of the character in padWith
to the end of
string
so that it is at least padTo
characters long and returns
the result. If string
is already long enough, no padding is applied.
Adds a fromCodePoint
factory method to String
if
it is not implemented natively.
String.fromCodePoint(codePoint1[, codePoint2, ...])
See the MDN documentation for details.
Adds a codePointAt
method to String.prototype
if
it is not implemented natively.
string.codePointAt(pos)
See the MDN documentation for details.


Controlling Your Daily Spending
We all know keeping our wallets closed from impulsive buys is important, but changing our habits accordingly is tougher. When it comes to changing my behavior no amount of tips and tricks really sticks until I change my mentality. For example, I knew that regularly going to the gym is a healthy habit, but I didn’t know that exercising also improves our cognitive function and memory. It wasn’t until I read the book “Spark” by John Ratey that I began to learn the “why” behind exercise. It struck me that exercise isn’t a chore, but a cheat code to help me learn faster and remember better. By viewing exercise from another lens I began to think “Exercise is doing a favor for myself” instead of “Exercise is an exhausting obligation”.
Being a smart spender is no exception. Understanding why we’re spending too much is key to changing our spending habits. I believe a lot of us today are trapped in what I call the Consumer Mindset.
 The lines between what we want and need are easily blurred because of how our peers and society around us have shaped how we think. Our first example looks into the perceived value of watches.
Originally watches were a tool to help us keep track of time. Today, watches have turned into symbolic accessories that represent more than their original function. We use them as objects to show off our status and taste instead of merely keeping time. Ironically, someone wearing a Rolex watch may seem wealthy since they’re so expensive, but what we don’t know is that they might’ve broken the bank just to get their paws on one! At the end of the day if we really wanted to check the time a simple battery powered Casio watch would do. In our digital age of smartphones and screens we always have access to time and watches have become even more unnecessary. The perceived value of watches is the result of manipulative marketing and calculated social engineering to create an illusionary value! Our justifications for an expensive brand name watch despite its actual utility is a classic example of a consumer mindset.
Another manifestation of the consumer mindset is our desire fit into social settings by presenting ourselves in certain light.
Clothes is an example of how societal norms influence us to buy more than we need. Any clothes would be appropriate to the gym, but it’s standard to have specific “gym clothes” to exercise in. Similarly, the idea of business appropriate clothing is a social construct we’ve needlessly created ourselves. Button-down collared shirts and modest dresses provide a professional image when in reality any casual outfit would do. While there’s certainly value in “dressing for success” the whole idea of wearing different outfits to match particular occasions isn’t mandatory, yet is universally accepted. Interestingly bikinis and swimming trunks are considered appropriate even though they cover as much as any other set of underwear. What we wear is largely dictated by how we want other people to perceive us.
A third value I believe most consumer orientated mindsets share is the desire to impress others.
While there’s nothing wrong with wanting to look good I see this mindset run rampant particularly in New York City. NYC is one of the densest cities in the world where the richest among us share the same streets as the homeless. The irony of Manhattan is the excessive amounts of cash people spend on housing for the sake of image. Because of its density, each square foot has an inflated premium relative to the rest of the United States. The end result is Manhattanites spend more on housing compared to everywhere. Often the justification for paying for such exorbitant prices is because where you live can speak volumes about how much you earn, your level of success in life, and standard of education.
Practical Applications
Lately I’ve been focusing on spending to make myself happier instead of impressing others. It sounds obvious once you hear it, but a surprising number of my purchases were really for the sake of a certain image instead of being necessary. It isn’t until deeper investigation of an extra drink, a night out with friends, or another epic vacaction that I began to realize how fruitless the entire venture was. Taking this advice to heart and applying it to my everyday life is easier said than done and remains a constant work in progress.
Here are some techniques I’ve heard from friends or applied myself.
$20 technique: Using only cash is a known for reducing spending. There’s something about physically letting go of money that turns it from a vague number into something physical that comes out of our pocket. A friend recommended me an idea where he only used $20 dollar bills for purchases. The rest of the bill would be saved as cash. For him, $20’s became a far more valuable bill not because of it’s monetary value, but because of how many bills he had left. It made him think twice before breaking a bill. Another perk was seeing the savings in cash by the end of the month. Accumulating a large number of smaller bills felt like he saved money for an end of the month reward.
Managing credit cards: Credit card bonuses are on the other side of the spectrum. By taking advantage of sign up bonuses I’ve earned hundreds of dollars worth of credits and cash back. For example, American Express Premier Rewards Gold Card provides a 25,000 point sign-up bonus after spending $2,000 within the first three months. That amounts to $125 cash back or up to $250 worth of gift cards. However, credit cards are a double edged sword. Entering the world of cashless spending can turn purchases into numbers on a screen instead of a tangible asset. It’s easier to spend when we don’t see a $100 Benjamin leaving our wallet, but letting go of five $20’s feels a lot more painful to part with.
Practice being thankful: This last bit attempts to address the root problem of having a consumer mindset. Personally, by better appreciating the things I already have makes me less likely to desire other things. Tim Ferriss’s podcast talks about how there are two ways to achieve the point of having everything you want:
- You can increase the things you have
- You can decrease the things you want
Most of the time we want things for the wrong reasons. We want to impress others, present ourselves in a certain way, or succumb to an impulse buy for the next awesome experience we just “can’t miss out on”. Our smartphones, laptops, cars, furniture, apartment, etc. are all large purchases that are perfectly fine but could always be a bit nicer. The next hot thing is always around the corner, and the idea that there’s something out there slightly better pushes us to buy more. A reality many of us deeply know is that we’re already lucky enough to have everything we really need.
Per usual, thanks for taking the time to read BrunchBucks. If you find a typo just contact me via email! Feel free to leave a comment below or share this with friends.
Subscribe via RSS


# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""
Helper module for simplified Qiskit usage.
In general we recommend using the SDK modules directly. However, to get something
running quickly we have provided this wrapper module.
"""
import warnings
import logging
from qiskit.compiler import transpile, assemble
logger = logging.getLogger(__name__)
[docs]def execute(experiments, backend,
basis_gates=None, coupling_map=None, # circuit transpile options
backend_properties=None, initial_layout=None,
seed_transpiler=None, optimization_level=None, pass_manager=None,
qobj_id=None, qobj_header=None, shots=1024, # common run options
memory=False, max_credits=10, seed_simulator=None,
default_qubit_los=None, default_meas_los=None, # schedule run options
schedule_los=None, meas_level=2, meas_return='avg',
memory_slots=None, memory_slot_size=100, rep_time=None, parameter_binds=None,
seed=None, seed_mapper=None, # deprecated
config=None, circuits=None,
**run_config):
"""Execute a list of circuits or pulse schedules on a backend.
The execution is asynchronous, and a handle to a job instance is returned.
Args:
experiments (QuantumCircuit or list[QuantumCircuit] or Schedule or list[Schedule]):
Circuit(s) or pulse schedule(s) to execute
backend (BaseBackend):
Backend to execute circuits on.
Transpiler options are automatically grabbed from
backend.configuration() and backend.properties().
If any other option is explicitly set (e.g. coupling_map), it
will override the backend's.
basis_gates (list[str]):
List of basis gate names to unroll to.
e.g:
['u1', 'u2', 'u3', 'cx']
If None, do not unroll.
coupling_map (CouplingMap or list):
Coupling map (perhaps custom) to target in mapping.
Multiple formats are supported:
a. CouplingMap instance
b. list
Must be given as an adjacency matrix, where each entry
specifies all two-qubit interactions supported by backend
e.g:
[[0, 1], [0, 3], [1, 2], [1, 5], [2, 5], [4, 1], [5, 3]]
backend_properties (BackendProperties):
Properties returned by a backend, including information on gate
errors, readout errors, qubit coherence times, etc. For a backend
that provides this information, it can be obtained with:
``backend.properties()``
initial_layout (Layout or dict or list):
Initial position of virtual qubits on physical qubits.
If this layout makes the circuit compatible with the coupling_map
constraints, it will be used.
The final layout is not guaranteed to be the same, as the transpiler
may permute qubits through swaps or other means.
Multiple formats are supported:
a. Layout instance
b. dict
virtual to physical:
{qr[0]: 0,
qr[1]: 3,
qr[2]: 5}
physical to virtual:
{0: qr[0],
3: qr[1],
5: qr[2]}
c. list
virtual to physical:
[0, 3, 5] # virtual qubits are ordered (in addition to named)
physical to virtual:
[qr[0], None, None, qr[1], None, qr[2]]
seed_transpiler (int):
Sets random seed for the stochastic parts of the transpiler
optimization_level (int):
How much optimization to perform on the circuits.
Higher levels generate more optimized circuits,
at the expense of longer transpilation time.
0: no optimization
1: light optimization
2: heavy optimization
pass_manager (PassManager):
The pass manager to use during transpilation. If this arg is present,
auto-selection of pass manager based on the transpile options will be
turned off and this pass manager will be used directly.
qobj_id (str):
String identifier to annotate the Qobj
qobj_header (QobjHeader or dict):
User input that will be inserted in Qobj header, and will also be
copied to the corresponding Result header. Headers do not affect the run.
shots (int):
Number of repetitions of each circuit, for sampling. Default: 2014
memory (bool):
If True, per-shot measurement bitstrings are returned as well
(provided the backend supports it). For OpenPulse jobs, only
measurement level 2 supports this option. Default: False
max_credits (int):
Maximum credits to spend on job. Default: 10
seed_simulator (int):
Random seed to control sampling, for when backend is a simulator
default_qubit_los (list):
List of default qubit lo frequencies
default_meas_los (list):
List of default meas lo frequencies
schedule_los (None or list[Union[Dict[PulseChannel, float], LoConfig]] or
Union[Dict[PulseChannel, float], LoConfig]):
Experiment LO configurations
meas_level (int):
Set the appropriate level of the measurement output for pulse experiments.
meas_return (str):
Level of measurement data for the backend to return
For `meas_level` 0 and 1:
"single" returns information from every shot.
"avg" returns average measurement output (averaged over number of shots).
memory_slots (int):
Number of classical memory slots used in this job.
memory_slot_size (int):
Size of each memory slot if the output is Level 0.
rep_time (int): repetition time of the experiment in μs.
The delay between experiments will be rep_time.
Must be from the list provided by the device.
parameter_binds (list[dict{Parameter: Value}]):
List of Parameter bindings over which the set of experiments will be
executed. Each list element (bind) should be of the form
{Parameter1: value1, Parameter2: value2, ...}. All binds will be
executed across all experiments, e.g. if parameter_binds is a
length-n list, and there are m experiments, a total of m x n
experiments will be run (one for each experiment/bind pair).
seed (int):
DEPRECATED in 0.8: use ``seed_simulator`` kwarg instead
seed_mapper (int):
DEPRECATED in 0.8: use ``seed_transpiler`` kwarg instead
config (dict):
DEPRECATED in 0.8: use run_config instead
circuits (QuantumCircuit or list[QuantumCircuit]):
DEPRECATED in 0.8: use ``experiments`` kwarg instead.
run_config (dict):
Extra arguments used to configure the run (e.g. for Aer configurable backends)
Refer to the backend documentation for details on these arguments
Note: for now, these keyword arguments will both be copied to the
Qobj config, and passed to backend.run()
Returns:
BaseJob: returns job instance derived from BaseJob
Raises:
QiskitError: if the execution cannot be interpreted as either circuits or schedules
"""
if circuits is not None:
experiments = circuits
warnings.warn("the `circuits` arg in `execute()` has been deprecated. "
"please use `experiments`, which can handle both circuit "
"and pulse Schedules", DeprecationWarning)
# transpiling the circuits using given transpile options
experiments = transpile(experiments,
basis_gates=basis_gates,
coupling_map=coupling_map,
backend_properties=backend_properties,
initial_layout=initial_layout,
seed_transpiler=seed_transpiler,
optimization_level=optimization_level,
backend=backend,
pass_manager=pass_manager,
seed_mapper=seed_mapper, # deprecated
)
# assembling the circuits into a qobj to be run on the backend
qobj = assemble(experiments,
qobj_id=qobj_id,
qobj_header=qobj_header,
shots=shots,
memory=memory,
max_credits=max_credits,
seed_simulator=seed_simulator,
default_qubit_los=default_qubit_los,
default_meas_los=default_meas_los,
schedule_los=schedule_los,
meas_level=meas_level,
meas_return=meas_return,
memory_slots=memory_slots,
memory_slot_size=memory_slot_size,
rep_time=rep_time,
parameter_binds=parameter_binds,
backend=backend,
config=config, # deprecated
seed=seed, # deprecated
run_config=run_config
)
# executing the circuits on the backend and returning the job
return backend.run(qobj, **run_config)


You can view your unsolved/solved problems, sort them, filter by volume, etc. If you just want to solve as many problems as quickly as possible, it's convenient to pick problems according to the dacu (distinct accepted users) in descending order. The bigger the dacu the easier the problem should be and the more probable it will appear in the UVa discussion board. The "solved view" sorted on the "diff" column shows your solved problems ordered by the runtime difference with the fastest solution (i.e., how far is the room for improvement can be made to your code). It will be fun tweaking your code as it may requires a whole different algorithm to make a big runtime improvement.
|
|


Make your own website in a few clicks! Mobirise helps you cut down development time by providing you with a flexible website editor with a drag and drop interface.
Bootstrap 3 has been noted as one of the most reliable and proven frameworks and Mobirise has been equipped to develop websites using this framework.
One of Bootstrap 3's big points is responsiveness and Mobirise makes effective use of this by generating highly responsive website for you.
Google has a highly exhaustive list of fonts compiled into its web font platform and Mobirise makes it easy for you to use them on your website easily and freely.
Mobirise gives you the freedom to develop as many websites as you like given the fact that it is a desktop app.
Mobirise comes with huge collection of pre made layouts to help make your development faster.
ADDRESS
1234 Street Name
City, AA 99999
CONTACTS
Email<EMAIL_ADDRESS>Phone: +1 (0) 000 0000 001
Fax: +1 (0) 000 0000 002


#include <component.hpp>
|
| | Component (std::shared_ptr< SpaCommunicator > communicator=nullptr, LogicalAddress address=LogicalAddress(0, 0), LogicalAddress subnetManagerAddress=LogicalAddress(0, 0)) |
| |
| virtual | ~Component () |
| |
| void | publish () |
| |
| virtual void | handleSpaData (SpaMessage *)=0 |
| |
| virtual void | preInit () |
| |
| virtual void | listen () |
| |
| virtual void | init ()=0 |
| |
| void | sendMsg (SpaMessage *message, ssize_t len) |
| |
| void | receiveMessage (SpaMessage *) |
| |
| void | handleSubscriptionReply (SpaMessage *) |
| |
| void | registerSubscriptionRequest (SpaMessage *) |
| |
| void | receiveBuffer (cubiumClientSocket_t *) |
| |
| void | subscribe (LogicalAddress producer) |
| |
| void | subscribe (LogicalAddress producer, uint8_t priority, uint32_t leasePeriod, uint16_t deliveryRateDivisor) |
| |
| virtual void | sendData (LogicalAddress)=0 |
| |
| void | sendPayload (std::string payload, LogicalAddress destination) |
| |
| template<typename T > |
| void | sendPayload (T payload, LogicalAddress destination) |
| |
| bool | addSubscriber (LogicalAddress, uint16_t) |
| |
◆ Component()
◆ ~Component()
| virtual Component::~Component |
( |
| ) |
|
|
inlinevirtual |
◆ addSubscriber()
◆ handleSpaData()
| virtual void Component::handleSpaData |
( |
SpaMessage * |
| ) |
|
|
pure virtual |
◆ handleSubscriptionReply()
| void Component::handleSubscriptionReply |
( |
SpaMessage * |
message | ) |
|
◆ init()
| virtual void Component::init |
( |
| ) |
|
|
pure virtual |
◆ listen()
| virtual void Component::listen |
( |
| ) |
|
|
inlinevirtual |
◆ preInit()
| virtual void Component::preInit |
( |
| ) |
|
|
inlinevirtual |
◆ publish()
| void Component::publish |
( |
| ) |
|
◆ receiveBuffer()
◆ receiveMessage()
| void Component::receiveMessage |
( |
SpaMessage * |
message | ) |
|
◆ registerSubscriptionRequest()
| void Component::registerSubscriptionRequest |
( |
SpaMessage * |
message | ) |
|
◆ sendData()
◆ sendMsg()
| void Component::sendMsg |
( |
SpaMessage * |
message, |
|
|
ssize_t |
len |
|
) |
| |
|
inline |
◆ sendPayload() [1/2]
| void Component::sendPayload |
( |
std::string |
payload, |
|
|
LogicalAddress |
destination |
|
) |
| |
|
inline |
◆ sendPayload() [2/2]
◆ subscribe() [1/2]
◆ subscribe() [2/2]
| void Component::subscribe |
( |
LogicalAddress |
producer, |
|
|
uint8_t |
priority, |
|
|
uint32_t |
leasePeriod, |
|
|
uint16_t |
deliveryRateDivisor |
|
) |
| |
◆ address
◆ communicator
◆ dialogId
| uint16_t Component::dialogId |
|
protected |
◆ lastCourier
◆ m_subscribers
| std::mutex Component::m_subscribers |
◆ publishIter
| uint8_t Component::publishIter |
|
protected |
◆ subnetManagerAddress
◆ subscribers
The documentation for this class was generated from the following files:


--- layout: page title: About header-img: "img/about-bg.png" ---
My name is John Kundycki, I live in Atlanta and I'm an aspiring Data Scientist. I'm currently studying at Flatiron School to make a career switch from the world of biology and chemistry to the world of data and machine learning.


A popular method in 3D object classification is to use multiple 2D images (views) of the 3D object and pass through independent CNN networks. Recent research in generative 3D deep learning includes generating 3D voxelized objects using the VAE-GAN architecture (3D-VAE-GAN). In this project, I extend the existing 3D-VAE-GAN to include multiple views of 2D images for generating voxel based 3D objects. I found that my method had a lower average reconstruction loss on the test dataset.
[report] [code] [slides]
Using the DuckieTown self driving car environment, the agent learns policies to drive in a straight line using the DDPG reinforcement learning algorithm. I experimented with two different state representations: one with raw images directly from the simulator, and the second with a VAE compressed version of the image to a single dimensional vector. The idea was that if the agent learns from a lower dimensional state representation, it may learn better policies or learn policies quicker than using raw images. My results showed that this was not true, and using raw images outperformed the latent representations.
[report] [code]
How could a robot learn to catch a ball thrown in its direction? This was the main question we aimed to tackle for our senior design project.
Our robot was a XY style plotter robot with a cup attached to a gantry plate.
The robot's goal was to go to the landing position of the ball before it landed. It used Q-Learning with a state representation of (x,y,velocity) of the ping pong ball and received a reward based on the Euclidean distance between the ball and the gantry plate.
The ball position was determined by a camera above the ramp and two laser pointers measured the velocity.
A Unity simulation of our enviornment was used to train the agent then transfered to the real life robot.
[paper] [code][slides]
This project experiments with language models to generate both hip hop and gospel lyrics. We scraped the LyricWiki website to generate our dataset, and experimented with bigram, trigram, and LSTM language models.
[report] [code]
Top-down fantasy RPG created in C++ with the SFML graphics library. The player can fight monsters, level up, explore the world, and fight bosses!
[code]


method to create the children servers
method for creating an individual server
method for creating an individual server
a boolean to indicate whether this new server is the master or not
the position inside the internal arraybuffer at which this server is going to be inserted
method that raises an error if we get a message we can't handle
method that raises an error if we get a message we can't handle
the actor that received the message
the message that was sent
method to hold a vote for a new master
method that sets up the starting state of the replication cluster
sends the message on to all the child nodes
sends the message on to all the child nodes
the message to pass on
actions to be performed on server startup
actions to be performed on server startup
method to request a vote for a new master from a particular server
method to request a vote for a new master from a particular server
the index of the vote in question.
method called at set intervals to check that the current master is still alive and elect a new master if not
method for scheduling the next master checkup
this is a replication cluster of several servers to simulate basic availability
17th july 2015


Analysis is based on Lending Club dataset of loans data since 2011, when current credit policy started to apply. Data on over 600 thousand lenders is available (updated on June 30th).
I assume that actual number of loan life could be predicted by latent variable 'loan strain' associated with borrower's financial condition (income, employment etc.), loan configuration (assigned grade, term, etc.) and other extraneous factors. Little strain leads to pre-mature payments while high strain leads to defaults. Moreover we could identify what parameters of loan could be manipulated to reach target level of strain.
See MoreLending Club is peer-to-peer finance service; it provides lenders and borrowers platform to lend money directly. Lending Club makes money by charging investors 1% of total receipts during loan payment and charging lenders origination fee. Origination fee depends on assigned loan grade and is instant, fixed payment. Commission from investors receipts on other hand is variable and depends on for how long borrower decides to extend her payments. For example, borrower may decide to repay loans instantly, with no penalty applied. This project attempts to evaluate what parameters associate with lenders period of payment.
It is obvious that over 60% of borrowers pay their loan 2 or more years earlier, which is arguably very high rate.
Scatterplots below show simple association for sample of data between number of periods paid pre-maturely (top left corner) and other variables. It signals lack of simple linear associations. I want to tackle this challenge by applying machine learning techniques.
Your estimate is:


Home
Animation
Analysis
Each State
All States
How we did it?
How we did it?
Tools:
Data process:
Python
CouchDB
Data Visualization:
D3.js
Web:
PHP
DreamWeaver
Reference:
Data resources:
WEATHER ANOMALIES U.S. Outliers 1964-2013
Inspired by:
U.S. Daily Temperature Anomalies 1964-2013
Our draft:


We have extensive experience of delivering projects using various open source technologies across the full stack. Which technologies?
We have delivered client projects using HTML, Angularjs, Javascript, Typescript, Reactjs, RxJs.
We have extensive experience in delivering server-side components using Nodejs and Expressjs. Node/ Express and in fact the whole MEAN stack allows us to build fast, scalable server-side components quickly.
NoSQL solutions are not always suitable for all projects, but where they are appropriate, we have the skills to deliver solutions using, for example, Redis or, for more complex data, MongoDb.
We have experience of delivering projects using big-data technologies such as Apache Storm, Kafka and Apache Spark. We've delivered streaming big-data solutions to financial institutions.
We delivered delivered a real-time stream analytics system using Apache Storm as the backbone of the system, with Esper as the rule engine, Nodejs/Express server-side and HTML 5 UI.


[gecode-users] Customised static variable ordering
Guido Tack
tack at ps.uni-sb.de
Sun Sep 27 22:46:58 CEST 2009
Chris Mears wrote:
> Hello Gecoders,
>
> I'd like to perform a depth first search with a specific static
> variable
> ordering. I have a matrix of integer variables and I want to label
> the
> top row first, then the left column, then the rest of the matrix in
> standard top-to-bottom, left-to-right order.
[...]
> I have managed to achieve the ordering I want, like this (with the new
> bits marked with comments):
>
> class Problem : public Space {
> IntVarArray cells;
> IntVarArray ordering; // *** added this array ***
> Problem(int n) {
> Matrix<IntVarArray> m(cells, n, n);
> // ...
> // set up constraints on cells via m
> // ...
> // *** added this block ***
> int index = 0;
> for (int c = 0 ; c < n ; c++)
> ordering[index++] = m(c,0);
> for (int r = 1 ; r < n ; r++)
> ordering[index++] = m(0,r);
You can use m.row and m.col here, like this:
branch(*this, m.row(0), ...);
branch(*this, m.col(0), ...);
> for (int r = 1 ; r < n ; r++)
> for (int c = 1 ; c < n ; c++)
> ordering[index++] = m(c,r);
> // *** search on "ordering" instead of "cells" ***
> branch(*this, cells, INT_VAR_NONE, INT_VAR_MIN);
Here you could just branch over the whole thing, as at this point the
first row and column will already be assigned and thus ignored in the
branching:
branch(*this, cells, ...);
> This seems to work. My question: is this the best way to do it? (It
> just occurred to me that maybe it could be done using Slices -- is
> that
> right?)
It's merely a matter of taste, not of efficiency, really.
Cheers,
Guido
More information about the gecode-users
mailing list


FormGroup
React wrapper component that tracks the state of an aribratry number of FormFields
<FormGroup> Component
Required Props:
groupName: string
Optional Props:
errors: object | boolean = false
style: object = {}
value: object = {}
valid: boolean = false
onBlur: function(formState: object)
onChange: function(formState: object)
onSubmit: function(formState: object)
children: <FormField> | child elements
Example:
<FormGroup groupName={'login'} value={{'name': 'Tom'}} onChange={someFunction} style={{background:grey}} valid/> <FormField /> <FormGroup />
Description
FormGroup components wrap a form element, keeping track of its current state, and can be configured to inform parent components when the state changes.
Props
Details for properties that can be passed
Prop Name |
Description |
| groupName: string | Unique name by which to identify the FormGroup Required | errors: object | boolean | Sets errors on FormGroup: false if the group is valid or an object with the error names as fields and any additional info about the errors as the values. Default value is false. |
| style: object | Sets inline styling. Default value is an empty object. |
| value: object | Sets the values for any nested FormFields. Default value is empty object. |
| valid: boolean | Manually sets whether the FormGroup is valid. Default value is false; |
| onBlur: function(formState: object) |
Function called whenever an onBlur event is triggered for any nested FormField. The function will automatically be passed the FormGroup's current state. By default, no function will be executed onBlur unless one is passed as a prop. |
| onChange: function(formState: object) |
Function called whenever an onChange event is triggered for any nested FormField. The function will automatically be passed the FormGroup's current state. By default, no function will be executed onChange unless one is passed as a prop. |
| onSubmit: function(formState: object) |
Function called whenever an onSubmit event is triggered for the form. The function will automatically be passed the FormGroup's current state. By default, no function will be executed onSubmit unless one is passed as a prop. |
| children: child elements | Any children FormField components or html elements to render. |


Password Expiring
Your password will expire in
38 days.
Would you like to change it now?
Change Password
Change it later


Metal is the primary resource used in the foundation of your Empire. At greater depths, the mines can produce more output of viable metal for use in the construction of buildings, ships, defence systems, and research. As the mines drill deeper, more energy is required for maximum production. As metal is the most abundant of all resources available, its value is considered to be the lowest of all resources for trading.
| Level | Production/h | Difference | Difference/Level | Energy Balance: | Difference | Protected |
|---|---|---|---|---|---|---|
| 20 | 28.252 | -9.352 | -4.382 | -1.346 | 445 | 61.024 |
| 21 | 32.634 | -4.970 | -4.970 | -1.555 | 236 | 70.489 |
| 22 | 37.604 | 0 | 0 | -1.791 | 0 | 81.224 |
| 23 | 43.246 | 5.642 | 5.642 | -2.060 | -269 | 93.411 |
| 24 | 49.637 | 12.033 | 6.391 | -2.364 | -573 | 107.215 |
| 25 | 56.882 | 19.278 | 7.245 | -2.709 | -918 | 122.865 |
| 26 | 65.072 | 27.468 | 8.190 | -3.099 | -1.308 | 140.555 |
| 27 | 74.333 | 36.729 | 9.261 | -3.540 | -1.749 | 160.559 |
| 28 | 84.791 | 47.187 | 10.458 | -4.038 | -2.247 | 183.148 |
| 29 | 96.600 | 58.996 | 11.809 | -4.601 | -2.810 | 208.656 |
| 30 | 109.928 | 72.324 | 13.328 | -5.235 | -3.444 | 237.444 |
| 31 | 124.950 | 87.346 | 15.022 | -5.951 | -4.160 | 269.892 |
| 32 | 141.883 | 104.279 | 16.933 | -6.757 | -4.966 | 306.467 |
| 33 | 160.944 | 123.340 | 19.061 | -7.665 | -5.874 | 347.639 |
| 34 | 182.406 | 144.802 | 21.462 | -8.687 | -6.896 | 393.996 |


Trivial UTF-8 is a small library for doing UTF-8-based in- and output on a Lisp implementation that already supports Unicode -- meaning char-code and code-char deal with Unicode character codes.
The rationale for the existence of this library is that while Unicode-enabled implementations usually do provide some kind of interface to dealing with character encodings, these are typically not terribly flexible or uniform.
The Babel library solves a similar problem while understanding more encodings. Trivial UTF-8 was written before Babel existed, but for new projects you might be better off going with Babel. The one plus that Trivial UTF-8 has is that it doesn't depend on any other libraries.
Trivial-utf-8 is released under a BSD-style license (see source file). The latest release can be downloaded from http://common-lisp.net/project/trivial-utf-8/trivial-utf-8.tgz, or installed with asdf-install.
A darcs repository with the most recent changes can be checked out with:
> darcs get http://common-lisp.net/project/trivial-utf-8/darcs/trivial-utf-8
Or look at it online.
The trivial-utf-8-devel mailing list can be used for any questions, discussion, bug-reports, patches, or anything else relating to this library. Or mail the author/maintainer directly: Marijn Haverbeke.
function string-to-utf-8-bytes (string) => array of (unsigned-byte 8)
Convert a string into an array of unsigned bytes containing its utf-8 representation.
function utf-8-bytes-to-string (bytes) => string
Convert a byte array containing utf-8 encoded characters into the string it encodes.
function write-utf-8-bytes (string output &key null-terminate)
Write a string to a byte-stream, encoding it as utf-8.
function read-utf-8-string (input &key null-terminated stop-at-eof char-length byte-length)
Read utf-8 encoded data from a byte stream and
construct a string with the characters found. When
null-terminated
is given it will stop reading at a null
character, stop-at-eof
tells it to stop at the end of
file without raising an error, and the char-length
and
byte-length
parameters can be used to specify the maximum
amount of characters or bytes to read.
function utf-8-byte-length (string) => integer
Calculate the amount of bytes needed to encode a string.
function utf-8-group-size (byte) => integer
Determine the amount of bytes that are part of the character starting with a given byte.
condition utf-8-decoding-error
A condition of this type is raised whenever an incorrectly encoded character is encountered.
Back to Common-lisp.net.


--- layout: minimal title: "Links" permalink: /links/index.html description: "Lexicographically ordered links of Kyle Young's friends..." ---


Gateway
BOT
03-Nov-18 02:51 PM
[dscrd-cz] <regtable> I think
[dscrd-cz] <regtable> That's how u code right?
[dscrd-cz] <Oszy> if it was all bip39 compatible word
[dscrd-cz] <sgt-pot-smoker> i hope whoever wins it posts the seed after so we can all
[dscrd-cz] <PTYX> Yeah whoever wins should definitely post their method
[dscrd-cz] <regtable> Function a(){} debug(a) works or not guess and guess again
[dscrd-cz] <PTYX> Like @regtable beautiful map
[dscrd-cz] <regtable> Yeah it's madness method
[dscrd-cz] <sgt-pot-smoker> @PTYX did you make it you say?
[dscrd-cz] <regtable> No the chain made it itself
[dscrd-cz] <regtable> New export privkeys format
[dscrd-cz] <PTYX> @sgt-pot-smoker yea I made it last night
[dscrd-cz] <sgt-pot-smoker> u did good dude
[dscrd-cz] <sgt-pot-smoker> XD
[dscrd-cz] <regtable> Have you assessed the conversion rate yet?
[dscrd-cz] <Emmanuel> imagine aliens finding this chat log after 50000 years
[dscrd-cz] <sgt-pot-smoker>
[dscrd-cz] <PTYX> Aliens would surely be holding chainzilla and kmd
[dscrd-cz] <regtable> Ok so i have an idea... let's all spam words and alternatives the dictionary attack it
@Chainzillaio @KomodoPlatform @VerusCoin @utrumdotio @TheCryptoZombie @NEMofficial Out of ideas but here’s what I know:
The QR code leads here:
https://t.co/xRvw47nQcd
The Binary code gives the same message as the QR code:
11 words. no plurals. follow the lines. x mar...
[dscrd-cz] <PTYX> Who is that on discord?
[dscrd-cz] <sgt-pot-smoker> i need chainzilla lol.
[dscrd-cz] <sgt-pot-smoker> its like pokemon. gotta collect them all
[dscrd-cz] <regtable> Lol
[dscrd-cz] <PTYX>
[dscrd-cz] <Oszy> i am sure i am only slipping on that bloody clown
[dscrd-cz] <regtable> This has stopped me working on mac compiles and I am glad of it
[dscrd-cz] <regtable> Ronald
[dscrd-cz] <Oszy> i know who it is
[dscrd-cz] <Oszy> furthermore i know who uses that image as a profile pic
[dscrd-cz] <Oszy> but no
[dscrd-cz] <regtable> I see it's that in depth
[dscrd-cz] <Oszy> not sure
[dscrd-cz] <regtable> I took it to next level tho.
[dscrd-cz] <regtable> Red line only
[dscrd-cz] <regtable> Moon tit face eye patch corner
(edited)
[dscrd-cz] <Oszy> but it says lineS
[dscrd-cz] <regtable> Yeah
[dscrd-cz] <sgt-pot-smoker> there is multiple red lines
[dscrd-cz] <regtable> No plurals
[dscrd-cz] <regtable> Lines
[dscrd-cz] <regtable> Line
[dscrd-cz] <sgt-pot-smoker>
[dscrd-cz] <regtable> Is that just part of decoration or a word.
[dscrd-cz] <regtable> As it goes through so I guess it's a word and hook hand is just a herring
[dscrd-cz] <sgt-pot-smoker> no ship is on original pic of map dude
[dscrd-cz] <sgt-pot-smoker> i think
[dscrd-cz] <regtable> Well
[dscrd-cz] <Oszy> hope zilla will cover the cost of my mental treatment
[dscrd-cz] <regtable> Ok so it is hook hand after blue man
[dscrd-cz] <regtable> Not gallion before
(edited)
[dscrd-cz] <Voight> How will we enter seed btw
[dscrd-cz] <Voight> 11 words or one word without space
@Chainzillaio @KomodoPlatform @VerusCoin @utrumdotio @TheCryptoZombie @NEMofficial The original treasure map can be found here:
https://t.co/xyxkPh3NGC
[dscrd-cz] <st3rling0x> @Iseki is going csi on the map
[dscrd-cz] <Iseki> I have nothing better to do in my life
[dscrd-cz] <PTYX> It would be funny if the first map was just a map to the original map
[dscrd-cz] <sgt-pot-smoker> u dropping hints there?
[dscrd-cz] <PTYX> No, the hints are in the binary code. I'm just poking fun.
[dscrd-cz] <sgt-pot-smoker> lol well you could be that savage lmao we dont know
[dscrd-cz] <Oszy> not funny
[dscrd-cz] <PTYX> Yeah if the price was like 100K I would make it extra complex. It's actually fairly straightforward.
[dscrd-cz] <regtable> When u know
[dscrd-cz] <PTYX> It'll make sense when you know
[dscrd-cz] <PTYX>
[dscrd-cz] <regtable> Same goes for most things crypto. It's voodoo till you understand it then it's just if or and else
[dscrd-cz] <SadykovT> is it one sentence or are the words unrelated ?
[dscrd-cz] <Mike_O.> Theres a lot of little things that make so many variables which is why its difficult and no one has solved it yet. Trying to keep track is crazy when trying everything. haha
[dscrd-cz] <PTYX> I think keeping track might be key
[dscrd-cz] <Mike_O.> Like is it.... kmd, KMD, komodo or even logo ??
[dscrd-cz] <PTYX> Because I've seen many people get real close
[dscrd-cz] <PTYX> With what I've seen in PM anyway
(edited)
[dscrd-cz] <Mike_O.> haha i wondered if people were trying to squeeze clues in private maessages yet or not.
[dscrd-cz] <Oszy> so we can pm you? wait i'll send what i have i want to know
[dscrd-cz] <Steve10> Any way to crack it on mobile? I have some time just not at my computer anymore
[dscrd-cz] <sgt-pot-smoker> ronald or mcdonald or clown
[dscrd-cz] <regtable> List out words for each one like moon, deathstar, fake komodo kmd and so on for each image then use a programme to dictionary list all possible combinations
[dscrd-cz] <regtable> If I had the energy to do that I would. But macports has sapped me of it
[dscrd-cz] <regtable> I don't want to see code again after this compile
[dscrd-cz] <Oszy> i am generating badass addresses tho might keep some XDD
[dscrd-cz] <regtable> Haha.
[dscrd-cz] <regtable> It's worked anyways it's a. Topic of conversation and b. A conversion tool makes people b1 download a wallet b2. join discord b3. talk
[dscrd-cz] <sgt-pot-smoker> thing is have i got the seed to those badass addys ?
[dscrd-cz] <sgt-pot-smoker> we will never know lmao i tried so many
[dscrd-cz] <sgt-pot-smoker> i honestly cant think of anything new
[dscrd-cz] <Oszy> same
[dscrd-cz] <Oszy> we need the first letter of each word please
[dscrd-cz] <regtable> Word one.
[dscrd-cz] <Mike_O.> I thinkk we all can agree... moon is moon
[dscrd-cz] <Mike_O.> then it gets crazy lol
[dscrd-cz] <SadykovT> or start
[dscrd-cz] <regtable> Moon, bluebeam ,fake, landing, crater, alien,cheese,orbital,satellite,projection,celestial to name a few alternatives
[dscrd-cz] <sgt-pot-smoker> moon could be star
[dscrd-cz] <regtable> Really
[dscrd-cz] <Mike_O.> its not a star though


Click to Play/Pause Restful Music
RELAXER
Background music graciously provided by:
Fesliyan Studios music
https://www.fesliyanstudios.com
.


VBus/USB
Serial/LANGW
VBus/LAN
DL2/KM2
DL3
Connection Device
Select VBus Connection Device Type
Connection Identifier
Host address (IP or FQDN) for local LAN and for VBus.net or Serial Port Id for VBus/USB access
Connection Port
Default: 7053
VBus Password
Default: vbus
DL3 Channel 1
DL3 Channel 2
DL3 Channel 3
DL3 Channel 4
DL3 Channel 5
DL3 Channel 6
DL3 Channel 0
DL3 Channel
Required for DL3 only
Via tag
Required only for VBus.net access via DLx/KMx
VBus Interval


Activity title is required.
Short description is required.
Long description is required.
Address is required.


#{extends 'main.html' /} #{set title:'Are you sure you want to remove a module?' /} #{if dependentModuleVersions == null || dependentModuleVersions.isEmpty()}
Removing a published module from a public repository is very dangerous as it will break existing applications. Make sure you know what you are doing.
You should only do this in the following situations:
The following modules depend on this module version. You must delete them first.


Because I want this project to be natively supported and buildable on a myriad of platforms, I do something the majority of projects don't: having multiple project files for different IDEs available from the outset. This will hopefully enable people with preferred IDEs or editors to keep using them, rather than having to go through a painful porting process.
There are currently three supported ways of building the SBI project:
| Visual Studio 2013 | ||||||
| Qt Creator | ||||||
| cbuild |
Operating systems with a question mark have not had attempted builds, but have no foreseen issues if the relevant software dependencies are installed.
Please note this does not include third-party dependencies, and optional entities such as the Qt GUI library (default), which require other tools to be installed.
Visual Studio 2013 can only be run on Windows, so there can be no Linux/Unix support. Win32 is assumed by the source code and project files if Visual Studio is detected. Due to Visual Studio 2012's lack of certain C++11 features, it is not compatible by default; workarounds will likely work, but not be supported.
For specific instructions, see building with Visual Studio 2013.
Requires: Visual Studio 2013 (free Express or paid-for versions ok)
Qt Creator is supported on both Windows and Linux, and as a result the project can be built on either system using this. If using Windows, you will require a compiler: you can use mingw, a cygwin supported tool, etc., or even the CLI tools from Visual Studio 2013 itself. On Linux, install the Clang or GCC C++ compiler.
For specific instructions, see building with Qt Creator.
Requires: Qt Creator 3.1 or newer (Qt 5.3+), C++11 compiler
cbuild is a custom-built build tool, designed to be lightweight, customizable, clean and simple. Written in Ruby, you can customize your projects build process by editing the project ruby script; if you desire changes in the system setup, you can modify the cbuild script directly. As noted before, you will still require a compiler installed for your operating system in order to execute. The build script will need modifying to point to the compiler paths (examples are provided).
For specific instructions, see building with cbuild.
Requires: Ruby 2.0 or newer, C++11 compiler
Don't feel limited by what we have here. There's nothing stopping you from creating a custom makefile, using geany, Code::Blocks, KDevelop, or any other IDE there is out there. Hopefully the documentation for the above three projects will provide sufficient information to tailor your build environment to how you want it. If you do create any other alternatives, please consider sending them to me, and I can add them to the list!


By blood and death power can be gain By blood and death knowledge can be found Let this text be your first step on the pass to illumination


Building KDE
Frameworks 5 (KF5)
KDE Frameworks 5 is a collection of libraries based on top of Qt5 and
QML derived from the monolithic KDE 4 libraries. They can be used
independent of the KDE Display Environment (Plasma 5).
This package is known to build and work properly using an LFS-8.3
platform.
The instructions below build all of the KDE Frameworks packages in
one step by using a bash script.
Package Information
KF5 Dependencies
Required
Boost-1.68.0, extra-cmake-modules-5.49.0,
docbook-xml-4.5, docbook-xsl-1.79.2, giflib-5.1.4,
libepoxy-1.5.2, libgcrypt-1.8.3, libjpeg-turbo-2.0.0, libpng-1.6.35,
libxslt-1.1.32, lmdb-0.9.22, OpenSSL-1.0.2p Libraries, phonon-4.10.1, shared-mime-info-1.10, URI-1.74, and Wget-1.19.5 (required
to download the packages)
Recommended
Aspell-<IP_ADDRESS> (Dictionary backend for
Sonnet), Avahi-0.7 (DNS-SD backend for KDNSSD), libdbusmenu-qt-0.9.3+16.04.20160218
(built with qt5), NetworkManager-1.12.2 (needed to build
NetworkManager-Qt), and polkit-qt-0.112.0 (Authentication backend for
KAuth)
Optional
BlueZ-5.50 (needed to build Bluez-Qt), ModemManager-1.8.0 (needed to build
ModemManager-Qt)
Runtime dependency for FrameworkIntegration
Oxygen fonts and Noto
fonts
Runtime dependencies for kapidox
Doxygen-1.8.14, Jinja2 , and
PyYAML
Additional image formats support in KImageFormats
JasPer-2.0.14 and OpenEXR
Optional dependencies for KIO
MIT Kerberos V5-1.16.1
Optional dependencies for Solid
UDisks-2.8.0, UPower-0.99.7 and
media-player-info
(runtime)
Optional dependency for KWallet
gpgmepp
Optional dictionary backends for Sonnet
Hspell and
Hunspell
Required dependencies for Prison
Datamatrix and QRencode
User Notes: http://wiki.linuxfromscratch.org/blfs/wiki/kf5
Downloading KDE Frameworks
The easiest way to get the KDE Frameworks packages is to use a
single wget to fetch
them all at once:
url=http://download.kde.org/stable/frameworks/5.49/
wget -r -nH -nd -A '*.xz' -np $url
The options used here are:
-r recurse through child directories
-nH disable generation of host-prefixed directories
-nd do not create a hierarchy of directories
-A '*.xz' just get the *.xz files
-np don't get parent directories
Setting Package Order
The order of building files is important due to internal
dependencies. Create the list of files in the proper order as
follows:
cat > frameworks-5.49.0.md5 << "EOF"
1b9a8d7fa78f14df0395d6533e07c233 attica-5.49.0.tar.xz
#44d277d5df5aa806f8caf4b12541b15c extra-cmake-modules-5.49.0.tar.xz
4b369263ce39d96093c64318bd69ac60 kapidox-5.49.0.tar.xz
541071a7a336ca167d66b6bee5bb98a0 karchive-5.49.0.tar.xz
3189f9540de1bcf93edeef7fc8fdb853 kcodecs-5.49.0.tar.xz
57f6c446d29483fb2cfb285eb956a91b kconfig-5.49.0.tar.xz
2e5cd09584c276416d56f66b8b3ee97b kcoreaddons-5.49.0.tar.xz
a496b86727152d8b59ed2a2228003ac2 kdbusaddons-5.49.0.tar.xz
19c1372fb1a702f57c66cf5803049d50 kdnssd-5.49.0.tar.xz
4a733f7fb98fb936d74a688fe9959dd7 kguiaddons-5.49.0.tar.xz
a04e3c5b5c23c273fbdbdb3dea8fc0a1 ki18n-5.49.0.tar.xz
c54edfca13c0e8dac161048db33b4bce kidletime-5.49.0.tar.xz
589ed57faba25f2014964619247aa28a kimageformats-5.49.0.tar.xz
4412ab5a5446aab1df6f7bb59bac4365 kitemmodels-5.49.0.tar.xz
72d840e8ce2324a8e01cd3f2a3c269b2 kitemviews-5.49.0.tar.xz
df18871fbc9494d6318d7106f5924c53 kplotting-5.49.0.tar.xz
3c6aa861640fd55a34e359ef798a916d kwidgetsaddons-5.49.0.tar.xz
4db7723226f6b0e0d8705d3fe53642a3 kwindowsystem-5.49.0.tar.xz
a4202fa94b64d65db2e4b7be34675c95 networkmanager-qt-5.49.0.tar.xz
391b3473e9e5d31d6e301f27e657ae4f solid-5.49.0.tar.xz
f3e739976224f0b14ae653534e503df4 sonnet-5.49.0.tar.xz
c068e97cfc0a42f0d32ca927a12691fe threadweaver-5.49.0.tar.xz
ed2183a6db12ce48f96b844287e53925 kauth-5.49.0.tar.xz
6790087dd73139a6e21e3cdf663271e5 kcompletion-5.49.0.tar.xz
c8c73f76432306b98ef038418c62ce44 kcrash-5.49.0.tar.xz
9376c84a3f70b95ae0141d90e1aaf165 kdoctools-5.49.0.tar.xz
9e690e1d76196c092b34605336e16ccb kpty-5.49.0.tar.xz
9424c658138501742a2af85495c47f60 kunitconversion-5.49.0.tar.xz
82d5d219494a2ad1514157a7064521d0 kconfigwidgets-5.49.0.tar.xz
26524fb8e33b8ab3aebf86ec078c7518 kservice-5.49.0.tar.xz
712658831c71f5127762ffa0016a7a39 kglobalaccel-5.49.0.tar.xz
232e476d2d59b789a10c7be3cb6832a0 kpackage-5.49.0.tar.xz
57a2a02a7061040a6a437a1df6dacbd8 kdesu-5.49.0.tar.xz
f98c6e3ab806c0f76ab76f0291e4dd93 kemoticons-5.49.0.tar.xz
bad840d753b545cc1d166c773d1c284c kiconthemes-5.49.0.tar.xz
f26fc58203dcad45d3c20545c5a48e53 kjobwidgets-5.49.0.tar.xz
2d276031a63a7bc76258991472056f5a knotifications-5.49.0.tar.xz
012e92d2f2ce4574d2d3d0dbddc748af ktextwidgets-5.49.0.tar.xz
009205833a4135eee008b6ea55833bb2 kxmlgui-5.49.0.tar.xz
eb0c686f3c61cd74c1740a030bdc4206 kbookmarks-5.49.0.tar.xz
802c5985ccfff94cfa025d6a938e7476 kwallet-5.49.0.tar.xz
826fc93fd2f0c337f7ef6bb8c10c0b22 kio-5.49.0.tar.xz
5febec6dc30c02caac9c46fc48d8a92a kdeclarative-5.49.0.tar.xz
b15758b0500e97866ea4b32dd042ae39 kcmutils-5.49.0.tar.xz
9431414418dbf8f906f4e13f33479256 kirigami2-5.49.0.tar.xz
d6771e1a02516c7bfb24ece46019abc4 knewstuff-5.49.0.tar.xz
175a23040d853e1710f525b42e22c6f5 frameworkintegration-5.49.0.tar.xz
f6b5fada29fde1223aa976476f583427 kinit-5.49.0.tar.xz
53fe83e865aa5ef5b50dbfc58037a80f knotifyconfig-5.49.0.tar.xz
f045b11f61eb244a9636e87eef84c496 kparts-5.49.0.tar.xz
9ed8874d043d2faafa28bf5ed2e3ea2a kactivities-5.49.0.tar.xz
d47cdb541b3f4a3823dd420db170964d kded-5.49.0.tar.xz
#014cde3b2f046494845bd88c8abc5883 kdewebkit-5.49.0.tar.xz
4b9837a0c1bc5bdb9acd146e0004759b syntax-highlighting-5.49.0.tar.xz
3fdec786eb549cdb398c9da23e1eb94e ktexteditor-5.49.0.tar.xz
6b4322afedde3304387c459d133c5d1e kdesignerplugin-5.49.0.tar.xz
5d4800ad4363d836c26b374c97d8be58 kwayland-5.49.0.tar.xz
913a57607b9c57daef88c90356f55986 plasma-framework-5.49.0.tar.xz
3a18f1b5eb357a16a786b30f12b16028 modemmanager-qt-5.49.0.tar.xz
ede339e08f7432f94ab85093241e104c kpeople-5.49.0.tar.xz
36d5ea545b972d275b4fde563202fed3 kxmlrpcclient-5.49.0.tar.xz
e311eee50522f739951b0fec7add2374 bluez-qt-5.49.0.tar.xz
ed176f7718b4f95688b7d4d109708d13 kfilemetadata-5.49.0.tar.xz
bbe82a79319abba8171769bb83b06d88 baloo-5.49.0.tar.xz
#aa29fe929300b41c44be52b9ee8a9e9c breeze-icons-5.49.0.tar.xz
#48136fe0337c9e3a7f57324b9b943d59 oxygen-icons5-5.49.0.tar.xz
037b33038aa30fb78cc05e4e7961b983 kactivities-stats-5.49.0.tar.xz
12b562c1509281001c6b32a5842e453b krunner-5.49.0.tar.xz
#dfc717b8fe63f3167d8bfea6f97b1ae6 prison-5.49.0.tar.xz
a84a244620b0febcb4a4527b0d7a6d09 qqc2-desktop-style-5.49.0.tar.xz
01ba726dc3fc0c440f9adacf66cb5681 kjs-5.49.0.tar.xz
22f9b04aebae7ddbf3fe5d3bfd93e541 kdelibs4support-5.49.0.tar.xz
b854adbf8ef148a426f079055e16b182 khtml-5.49.0.tar.xz
7025261ab8657c34b8110fd1419a6bc4 kjsembed-5.49.0.tar.xz
b9e38efe9fd70d30ff2275177ec8f95a kmediaplayer-5.49.0.tar.xz
7297399799ef96f2a29b9e35c0dc57a7 kross-5.49.0.tar.xz
ba7bac91aeeddb03631dd12b6d44f9e2 kholidays-5.49.0.tar.xz
17fd75131e1860a2b77021770de8d40c purpose-5.49.0.tar.xz
EOF
In the above list, notice that some files have been commented out
with a hash (#) character. The extra-cmake-modules entry has been
commented out because it was built earlier in the Introduction to
KDE. The icon packages are covered separately at breeze-icons-5.49.0 and oxygen-icons5-5.49.0. The
modemmanager-qt package may be built if its optional dependency has
been installed. The prison package (bar code reader) may be built
if the required external libraries are installed. The kdewebkit may
be built if the external package QtWebkit
has been built.
Installation of KDE Frameworks
Note
When installing multiple packages in a script, the installation
needs to be done as the root user. There are three general
options that can be used to do this:
-
Run the entire script as the root user (not recommended).
-
Use the sudo
command from the Sudo-1.8.23
package.
-
Use su -c "command
arguments" (quotes required) which will ask
for the root password for every iteration of the loop.
One way to handle this situation is to create a short
bash function that
automatically selects the appropriate method. Once the command is
set in the environment, it does not need to be set again.
as_root()
{
if [ $EUID = 0 ]; then $*
elif [ -x /usr/bin/sudo ]; then sudo $*
else su -c \\"$*\\"
fi
}
export -f as_root
Caution
If installing in /opt and there is an existing /opt/kf5 either as
a regular directory or a symbolic link, it should be
reinitialized (as root):
mv -v /opt/kf5 /opt/kf5.old &&
install -v -dm755 $KF5_PREFIX/{etc,share} &&
ln -sfv /etc/dbus-1 $KF5_PREFIX/etc &&
ln -sfv /usr/share/dbus-1 $KF5_PREFIX/share
First, start a subshell that will exit on error:
bash -e
Install all of the packages by running the following commands:
export CXXFLAGS='-isystem /usr/include/openssl-1.0'
while read -r line; do
# Get the file name, ignoring comments and blank lines
if $(echo $line | grep -E -q '^ *$|^#' ); then continue; fi
file=$(echo $line | cut -d" " -f2)
pkg=$(echo $file|sed 's|^.*/||') # Remove directory
packagedir=$(echo $pkg|sed 's|\.tar.*||') # Package directory
tar -xf $file
pushd $packagedir
mkdir build
cd build
cmake -DCMAKE_INSTALL_PREFIX=$KF5_PREFIX \
-DCMAKE_PREFIX_PATH=$QT5DIR \
-DCMAKE_BUILD_TYPE=Release \
-DBUILD_TESTING=OFF \
-Wno-dev ..
make
as_root make install
popd
as_root rm -rf $packagedir
as_root /sbin/ldconfig
done < frameworks-5.49.0.md5
exit
Note
Any modules that have been omitted can be installed later by
using the same mkdir build; cd build; cmake; make; make install
procedure as above.
Sometimes the installation paths are hardcoded into installed
files. If the installed directory is not /usr, rename the directory
and create a symlink:
mv -v /opt/kf5 /opt/kf5-5.49.0
ln -sfvn kf5-5.49.0 /opt/kf5
Command Explanations
-DCMAKE_PREFIX_PATH=$QT5DIR
: This
switch is used to allow cmake to find the proper Qt libraries.
-DCMAKE_BUILD_TYPE=Release
:
This switch is used to apply higher level of the compiler
optimizations.
-DBUILD_TESTING=OFF
: This
switch is used to prevent building test programs and libraries that
are of no use to an end user.
Contents
Installed Programs:
There are 48 programs installed in
/opt/kf5/bin.
Installed Libraries:
There are too many kf5 libraries (191) to
list separately.
Installed Directories:
/opt/kf5 (symlink to
/opt/kf5-5.49.0)
Short Descriptions
|
checkXML5
|
is a tool to check for syntax errors in KDE DocBook XML
files.
|
|
depdiagram-generate
|
is a tool to generate a dependency diagram.
|
|
depdiagram-generate-all
|
is a tool to generate a dependency diagram for all
frameworks at once..
|
|
depdiagram-prepare
|
is a tool to prepare dot files.
|
|
desktoptojson
|
is a tool to convert a .desktop file to a .json file.
|
|
kactivitymanagerd
|
is the KDE Plasma Workspace Activity Manager.
|
|
kbuildsycoca5
|
rebuilds the KService desktop file system configuration
cache.
|
|
kcookiejar5
|
is a command line interface to the HTTP cookie store used
by KDE, a D-BUS service to store/retrieve/clean cookies.
|
|
kded5
|
consolidates several small services in one process.
|
|
kdeinit5
|
is a process launcher somewhat similar to the famous init
used for booting UNIX.
|
|
kf5-config
|
is a command line program used to retrieve information
about KDE installation or user paths.
|
|
kf5kross
|
executes kross scripts written in KDE Javascript, Python,
Ruby, Java and Falcon.
|
|
kgenapidox
|
is a tool to generate API documentation in the KDE style.
|
|
kgendesignerplugin
|
generates widget plugins for Qt(TM) Designer.
|
|
kglobalaccel5
|
is a daemon use to register the key bindings and for
getting notified when the action triggered.
|
|
kjs5
|
is KDE ECMAScript/JavaScript engine.
|
|
kjscmd5
|
is a tool for launching KJSEmbed scripts from the command
line.
|
|
kjsconsole
|
is a console for kjs5.
|
|
kmailservice5
|
is a mail service.
|
|
kpackagelauncherqml
|
is a commandline tool for launching kpackage QML
application
|
|
kpackagetool5
|
is a command line kpackage tool.
|
|
kreadconfig5
|
is a command line tool to retrieve values from KDE
configuration files.
|
|
kshell5
|
start applications via kdeinit.
|
|
ktelnetservice5
|
is a telnet service.
|
|
ktrash5
|
is a helper program to handle the KDE trash can.
|
|
kwalletd5
|
is the wallet manager daemon.
|
|
kwriteconfig5
|
is a command line tool to write values in KDE
configuration files.
|
|
meinproc5
|
converts DocBook files to HTML.
|
|
plasmapkg2
|
is a tool to install, list, remove Plasma packages
|
|
preparetips5
|
is a script to extract the text from a tips file.
|
|
solid-hardware5
|
is a command line tool to investigate available devices.
|
Last updated on 2018-08-20 18:36:12 -0700


Set me going and I'll periodically show you changes to your data
It's recommended you DON'T use the automatic data refresh feature of this viewer (controled with the red and green buttons at the top) unless you know what you're doing and really need to (ie for a local install).
For the most part you should be fine selecting the data source form the settings pane, configuring the options and hitting "Load Data Once" to set the app off. To reload the data, click the button again or use the l
key as a keyboard shortcut