2022-09-01
Yay! I got the pink noise gen bit working, modulated from LFO.
Decided it was a good time to pause, do some docs, see what was needed to tidy things up.
Replaced refs to 'Dreamachine' to 'ESPMachine', with generalising in mind.
The SSD1306 display bits got messed up, so replaced those, redid splash screen. (There must be a way of doing it without hacking into the driver source, but I can't be bothered looking right now).
2022-08-30
I got a fair bit further, but along the way did a git revert, wiped the notes...
DAC GPIO are 25, 26
2022-08-26
The queue between processes on Core 0 and Core 1 was almost working, but :
CORRUPT HEAP: Bad head
First probably was that I was setting the queue item size from an uninitialized struct (empty box!).
Fiddled around a bit elsewhere.
The labels bizarrely kept resetting to the initialized default. I couldn't see how to check these in the debugger, but then I realised that they don't need to be passed with the message! Much more stable now.
Ah...but I do still need to pass a ref. to the current mode...
I changed the splash screen :
2022-08-25
This thing is so concurrency-heavy!
So now, when the Mode is changed in Dreamachine.cpp, on Core 0, I need it to pass whatever values have changed over to DreamachineWaves on Core 1.
For a similar job, in LFO, it was textbook semaphore-based so I pretty much copy-and-pasted the relevant code.
Comms between cores is central to the whole application(s), so I really need a clear idea of what's going on.
A possibility would be to use RTOS Task Notifications, eg. with
https://www.freertos.org/RTOSTaskNotificationAsMailbox.html
But with this :
These are faster, and I could probably squeeze what's needed for Dreamachine into this approach, but I think it makes more sense to do it in a more general purpose way using FreeRTOS Queues.
https://www.freertos.org/Embedded-RTOS-Queues.html
So over to:
https://www.freertos.org/Documentation/RTOS_book.html Tutorial, Chapter 4, Queue Management
RTOS Reference Manual, P.163
https://techtutorialsx.com/2017/08/20/esp32-arduino-freertos-queues/
2022-08-24
I got past my annoying problem this morning. The encoder can now update the display.
Next problem is getting it to update eg. the LED frequency.
Does get confusing fast, the different scopes, what has to be static.
2022-08-23
I realised an easy (but still quite clean) way to handle the different application/UI modes, 'Brightness', 'Frequency' etc, was to implement them as (an array of) objects.
But last night, coding it up, ran into trouble. So I cut the code back to something really simple, there's still a disconnect somewhere. Just now I had a look, still couldn't see the problem.
Then I remembered I'd bought an ESP Prog JTAG board when I started working on Chatterbox. Could not get it to work then.
I just plugged it into Dreamachine - It Just Worked - and now I have proper debugging!!!!
<EMAIL_ADDRESS>``` TDI (Test Data In) TDO (Test Data Out) TCK (Test Clock) TMS (Test Mode Select) TRST (Test Reset) optional. On the ESP32, the JTAG pins are GPIO pins at the same time. So during debugging, you cannot use them. They are:
GPIO12 — TDI GPIO15 — TDO GPIO13 — TCK GPIO14 — TMS The reset pin (TRST) is not fully supported by OpenOCD. Fortunately, it’s optional. ```
<EMAIL_ADDRESS>I'm too tired to do any more tonight, but this should be a real timesaver. Proper magic!!!
2022-08-21
To try and sort out wonky organisation decided some visualisation would be useful.
Installed :
I went around and around in circles again - literally.
Getting the right bits static and the right pointer reference, hugely confusing.
But now the encoder is talking to the display via a callback to Dreamachine.cpp. Phew!!!
2022-08-20
It took me a long time, but I've now got an EncoderReader (wrapping both encoders) dispatching events. But the high-level organisation is now a bit wonky :)
2022-08-19
I just wasted a load more time unsuccessfully trying to implement the State pattern.
2022-08-15
Hah! I was setting sine wave LFO to 100Hz, Bitscope meter was saying it was 16.8Hz. Was going around in circles until I double-checked wih Bitscope DSO - that said 100Hz!
Ok, so that's near enough for now.
The noise generator bits are the fun part, leave for now.
Get the overall prog logic in place first.
Design Patterns book suggests State. Found a reasonably clear example :
https://refactoring.guru/design-patterns/state/cpp/example
Renaming State to Mode and Context to Dreamachine.
Nooo!
I got hopelessly confused, circular dependencies etc.
The functionality I need is very simple, I reckon I'll set it up with a simple switch(){} first, refactor later if it seems necessary.
2022-08-13
Renamed the LightWave class to LFO. It should be more general-purpose, not tied to how it is used.
Useful examples :
https://github.com/espressif/arduino-esp32/tree/master/libraries/ESP32/examples
2022-08-12
To try putting something on the DreamMachineWaves core, set up a timer to flash LEDs. Works a treat, at least up to 440Hz (tested with earpiece & guitar tuner!).
Code in LightWave class, derived from https://github.com/espressif/arduino-esp32/blob/master/libraries/ESP32/examples/Timer/RepeatTimer/RepeatTimer.ino
2022-08-11
LATER : got the encoder a bit closer, good enough for now. Split the processes off between the 2 ESP32 cores : DreamachineUI, DreamachineWaves
I got frustrated with the rotary encoder lib so have changed it radically, now is https://github.com/danja/Esp32RotaryEncoder
TODO :
encoder set current
state struct
2022-08-10
The other day I did get the LEDs basically working.
The code around the rotary encoders is pretty horrible, so (like the display) am putting it in a wrapper class.
I've got that basically working, still need to add button handler, tidy up.
It is possible to use the change interrupt directly, but has to happen fast or it crashes -
Guru Meditation Error: Core 1 panic'ed (Interrupt wdt timeout on CPU1)
"When an interrupt handler is called, it blocks the entire system. So it must only do minimal work and return quickly. Serial communication however is slow and causes long delays. Thus, your program is terminated by the watchdog ("wdt" is the abbreviation for the watchdog)."
Which explains why the lib exposes polling as the main access method.
But the lib examples are missing an obvious trick : use the interrupt call to set a flag. With the main loop checking flag, only updating values/display when it's changed.
Grrr. The button handling code in the lib is actually disabling the button interrupt.
Need to :
2022-08-02
Time to look at the main function of this thing : controlling the big LEDs.
I've rigged up LEDs on sunglasses with a stereo 3.5mm jack socket.
Because the LEDs might be out of circuit at times, I'll add a dummy load of 1k or so to their transistor drivers, collector to +ve.
Now I need to find two free GPIO pins that can do PWM.
GPIO 32 PWM LEDL GPIO 33 PWM LEDR
2022-07-30
rotary encoders + switches basically working - counting the wrong way, I need to look how the value scaling in the lib works.
Couple of related issues I had worth noting :
The rotary encoders I have are mounted on little PCBs with 3 resistors on their backs. I haven't bothered tracing tracks, but presumably pull-up or pull-down.
I tried using GPIO 2, which is connected to an onboard LED. Stupid idea to begin with, and in practice with a resistor connected to something, this stopped the program uploading.
In the encoder lib code, it has some lines like :
pinMode(this->encoderAPin, INPUT_PULLDOWN);
etc.
This seemed to conflict with the onboard resistors, I got around this by adding :
pinMode(ENCODER1CLK, INPUT);
etc.
After the encoder objects' creation, but before begin()
EARLIER
Rotary encoder time. There are quite a few libs that can manage these things, probably near-equivalent. If the encoder button can be handled here that'd be convenient. I'd prefer something interrupt-driven, polling can get messy fast. This lib appears to fit the bill : https://github.com/igorantolic/ai-esp32-rotary-encoder
So installed from PlatformIO. Now to pick GPIOs - I want ones without overloaded functionality I might need elsewhere.
I want 2 encoders (with buttons). Each needs 3 GPIOs : CLK, DT, SW
The list at https://randomnerdtutorials.com/esp32-pinout-reference-gpios/ is a great starting point (extract below)
I may use the DACs, GPIO25 GPIO26
I'm already using: GPIO 22 display SCL GPIO 21 display SDA
checking for potential later use, to connect UDA1334A I2S DAC in Chatterbox: GPIO 25 GPIO 26 GPIO 27
These look promising : GPIO 34 input only GPIO 35 input only GPIO 36 input only GPIO 39 input only
plus (both ADC/RTC, neither of which I need) GPIO 2 GPIO 4
Ok, so try:
Encoder1 ESP32 CLK GPIO 34 DT GPIO 35 SW GPIO 2 NO! 16
Encoder2 ESP32 CLK GPIO 36 DT GPIO 39 SW GPIO 4
Hmm, that's annoying, although this lib appears to be interrupt-driven, the examples all seem to poll. Not a big deal - I'll go along with the examples for now. If that doesn't seem nice, I must be able to add an interrupt callback encoderChanged() somewhere...
2022-07-30
I have the display working. Next step there is to make it usable. Wrap the display lib into a class that only exposes the functionality I need through simple functions.
The UI will be modal, with the press of a button changing mode.
The display is (rather bizarrely) split into two areas - a top 1/5 or so shows yellow, the rest shows blue.
I guess a simple way of exploiting this is to use the top (yellow) line to show current mode, area below the value.
Brightness : 70% Frequency : 33 Hz Phase : 90° Volume : 80% Wave : sine Noise : white
It's a dot matrix display so I guess it makes sense to exploit this with some kind of graphic indication as well as text. That suggests three functions :
drawLabel(labelString) drawValue(valueString) drawGraphic(graphicObject)
(The latter two can probably be wrapped together somehow, but that can wait until later)
rename to displayXXX()
probably need a display(labelString, valueString) ..?
https://github.com/adafruit/Adafruit_SSD1306
https://github.com/adafruit/Adafruit-GFX-Library
I noticed this, don't think it was necessary : https://rntlab.com/question/esp32-oled-ssd1306-issue/
2022-07-29
Had a bit of trouble writing to the ESP32, the USB connection wasn't been recognised.
ls /dev/ttyUSB*
lsmod|grep usbserial
sudo modprobe cp210x
sudo rmmod cp210x sudo insmod /lib/modules/5.15.0-43-generic/kernel/drivers/usb/serial/cp210x.ko
uninstall brltty
systemctl stop brltty-udev.service sudo systemctl mask brltty-udev.service systemctl stop brltty.service systemctl disable brltty.service
Got this display example to work (after adding forward function definitions) :
https://randomnerdtutorials.com/esp32-ssd1306-oled-display-arduino-ide/
I thought I'd better test the LEDs, just in case. Wound up doing some sums and measurements
The LEDs are rated at 1W, 3.2-3.4 V 350mA, but voltage drop was actually about 2v.
I aimed for 100mA drive from a BC109 on a 5v PSU.
With the BC109 common emitter, I found a base resistor of 680R (going to +3.3v) and a collector resistor of 10R (going through LED to +5v) gave me 95mA.
It's not exactly dazzling, but may be bright enough, is certainly good enough for now.
2022-07-23
The LED driving and signal generation should be straightforward enough, known territory.
This display is new to me, I reckon try to get that working first, then add rotary encoders.
Libraries :


Preparation time
less than 30 mins
Cooking time
10 to 30 mins
Serves
Serves 2
Treat someone special to this smart dinner for two. It’s surprisingly easy to make too.
For the duck, preheat the oven to 210C/425F/Gas 7.
Score the skin of the duck breasts in a criss-cross pattern.
Place the duck breasts in an ovenproof frying pan, skin-side down, and cook for 4-5 minutes, or until the fat is rendered. Add the apple to the pan.
When the duck skin is crisp and golden-brown, turn the duck breasts over and cook the other side for 1-2 minutes. Baste the duck with a knob of butter, then roast in the oven for 2-3 minutes (for medium), or until cooked to your liking.
Heat the fennel and coriander seeds in a dry frying pan until aromatic. Grind the seeds in a pestle and mortar. Add the nutmeg, cinnamon and orange zest. Stir in the honey and enough orange juice to give the glaze a good consistency.
Remove the duck breasts from the oven and brush the spice mixture over the duck breasts with a pastry brush. Baste the duck with its roasting juices and leave to rest for a few minutes.
Heat a frying pan until hot, add the duck stock and cook until the volume of liquid has reduced by half, then add the 25g/1oz of butter and whisk until well combined. Season with salt and freshly ground black pepper.
For the creamed Savoy cabbage, heat a lidded frying pan until hot and fry the bacon lardons, carrot and celeriac with the lid on for 4-5 minutes.
Add the cabbage and season, to taste, with salt and freshly ground black pepper.Cover with the lid and continue to cook for 3-4 minutes, or until the cabbage is tender. Add the cream and cook for 1-2 minutes, or until the cream has thickened.
To serve, spoon the cabbage onto serving plates and top with the roasted apples. Slice the duck breasts and place on top.


I'm a software engineer with a passion for breaking down complex problems and building iterative, testable, and well planned approaches to solving them. I have expertise in JavaScript, React, Ruby, Rails and SQL, and am excited to continue to learn new languages, frameworks and algorithms.
I also have extensive experience on the business, sales and marketing side of various technology companies. I'm the rare software engineer who has also signed-up six figure recurring revenue customers, managed lead generation efforts and forecast a high-growth company's P&L.
My technical and business background have made me a huge believer in ensuring there is robust communication and effective feedback loops between product/development and the other parts of the organization, particularly sales and customer service. Engendering a culture of user-centric product development is important to me and I'm looking to work with organizations and individuals who share that focus on the end-user.
When not working you'll likely find me at a CrossFit box or at home looking at pictures of cute dogs on Instagram and basketball highlights on YouTube.
A fullstack, single-page recipe management app inspired by the New York Times Cooking Site. I built a custom JSON API for AJAX calls to maintain an efficient, normalized Redux state. Utilizes React Transition Group to create advanced CSS transitions and hover-effects. Code kept DRY with the use of partials and re-used React presentational components
Surface To Air is inspired by the classic 1-player Atari game Missile Command. It involves a series of projectiles descending from the sky at various trajectories headed for the six cities on the ground. The player fires missiles from a fixed location via a crosshair contolled by the player via the mouse
A lightweight MVC framework built in Ruby. It utilizes the RACK webeserver interface to respond to HTTP requests with responses that render HTML template populated by modal data to the user
Ruby
Rails
JavaScript
React
Redux
HTML
CSS
jQuery
PostgreSQL
Git
Github
Heroku
AWS
RSpec


RUNow is a Java-based running application for Android. It is designed to help the users to track
and record runs and give them information about various aspects of the run like distance, pace,
duration and consumed calories. RUNow also saves completed runs records and allows the users to
look back at the recorded data from database and delete any record or erase all the entries. It is
designed for users of all ages who want to keep track of their workouts and see progress along the
way.
We aim to promote a healthy lifestyle for the users.
(Collaborator: Lin Che, Vreni Preußler, Zhenyu Wei)
This logo consists of an image of a running person, and it represents the core theme of this app. The green colour schema shows a healthy running lifestyle in nature.
The starting page shows the app logo and the name in the middle of the page. It introduces the colour concept of the app and leads directly to the main page of the application. At the bottom of the page, copyright is remarked.
At the top of the main activity, the switch button —“Theme” for different themes - day and night mode is
placed on the left corner which user can choose freely while running. Next to it in the right upper
corner, a button called “History” that leads to another page with the records of runs which the user can
manipulate.
The main activity of the application consists mostly of a map fragment that shows the current location
on a Google Maps Interface while running. During the run, a multi-coloured line shows the track
depending on the pace of runners. The line symbolises the pace of the run in three colours (red – yellow
– green) which are corresponding to three different ranges of pace, and red represents slow and green
represent fast.
Below the map, there is a dashboard with the information that is gathered while the user is running. The
app is controlled via three buttons at the bottom of the page.
Via the “start” button, the new running activity is started. While the user is running, certain
variables are gathered and displayed below the map fragment in respective TextViews, like distance,
pace, duration of the run and burned calories. The logo turns into a “pause” button as soon as an
activity is started and stops the tracking of the run and the calculation of the variables momentarily
until the run is continued via the same button means “resume” now. The “stop” button ends the recording
of the run and adds the tracked run to the run history(the local database), along with all calculated
variables.
In this application, we provide the day mode and night mode for better user experience during different lighting situation by toggling the switch. With the day mode, the UI is themed in a lighter colour tone of matching colour scheme as well as a customised styled map which is less detailed but actually tailored to the usage of runners during running. For example, it enhances the streets/parks and marked out the public transportation stations/highways, which could be useful information for runners. With the night mode, the UI is themed in a darker colour tone as well as the google map with matching colour scheme to the entire design.
The button with the “memory” icon on the top right corner in the main activity of the app leads to the record page. Via the “BACK” button, which is left of the “trash” button, the user is redirected to the main page. Moreover, via the “trash” button, you can clear all of the records (the whole table) at once. In addition, it also enables users to delete single entries with the “delete” button on the beginning of each row. On the record page, the run entries with time and calculated data including the ID for each entire, distances and consumed calories are listed in the main TextView.
In this running application, we also include an internal function of popping out points of interest
when the users approach some particular feature objects while running.
The places are: Alte Mensa, SLUB and Hülsse-Bau.
The distance threshold is set to 30m, which means when the runner approaches the above places within
30m, the
Icon will pop up as a hidden surprise of this app. Surprise, more fun!
Let's live a healthier life with this App!


math v0.2.0 Math.Enum
Math.Enum defines Math-functions that work on any collection extending the Enumerable protocol. This means Maps, Lists, Sets, etc., and any custom collection types as well.
Summary
Functions
Calculates the mean of a collection of numbers
Calculates the median of a given collection of numbers
Calculates the product, obtained by multiplying all elements in collection with eachother
Functions
Specs
mean(Enum.t) :: number
Calculates the mean of a collection of numbers.
This is the sum, divided by the amount of elements in the collection.
If the collection is empty, returns nil
Also see Math.Enum.median/1
Examples
iex> Math.Enum.mean [1,2,3]
2.0
iex> Math.Enum.mean 1..10
5.5
iex> Math.Enum.mean [1,2,3,4,5, -100]
-14.166666666666666
iex> Math.Enum.mean []
nil
Specs
median(Enum.t) :: number | nil
Calculates the median of a given collection of numbers.
- If the collection has an odd number of elements, this will be the middle-most element of the (sorted) collection.
- If the collection has an even number of elements, this will be mean of the middle-most two elements of the (sorted) collection.
If the collection is empty, returns nil
Also see Math.Enum.mean/1
Examples
iex> Math.Enum.median [1,2,3]
2
iex> Math.Enum.median 1..10
6.5
iex> Math.Enum.median [1,2,3,4,5, -100]
3.5
iex> Math.Enum.median []
nil


--- layout: default title: "You seem to be offline!" permalink: offline.html ---
Try reloading this page after you are connected to the internet :)


--- layout: page title: About header-img: "img/about-bg.png" ---
I recently decided to start the journey towards becoming a computer programmer.


It looks like your browser doesn't support cryptography. See
here for a list of browsers you can use.
Public key: share this!
Private key: save this!
Original message
Encryption key
Encrypted message
Original bytes
Public key for encryption
Result
Encoded message
Your private key
Special decoding key
Result


|
|
The test code for the classes of the namespace std_ext_adv
includes numerous examples of relatively simple uses of
the new containers and algorithms,
see files
"test_container.hpp"
,
"test_common.hpp"
,
"test_associative.hpp"
,
"test_sequence.hpp"
.
This section includes a number of practically useful applications.
Despite the fact that most of these applications are not completely trivial,
the new containers help develop effective and relatively simple solutions.
The aim of this section is to show how to use the new containers in order
to reduce the complexity of solutions in specific applications.
In order to simplify the demo code and focus on the main features of algorithms
based on the advanced data structures, the data members of classes specific to
numerical problem domains are of type int
. The algorithms operating with
integral types take advantage of precise values and use relational and equality
operators without a tolerance parameter. In practical applications, data types
and operations can be parameterized to support generic algorithms.
The efficient string algorithms and text editors are major applications
for advanced and augmented data structures.
Rope
data structure provides several string operations
more efficient than an array or a linked list.
An augmented Finger Tree is another data structure with comparable facilities.
It is used in the functional programming language Haskell for implementation of the
Data.Sequence
container.
The figure 1 of the section
Design and implementation of B+ trees
shows two representations of a string: one using an augmented array based B+ tree
and the other one using an array. The efficient string operations offered by
the B+ trees can be used through the sequence
container of
the namespace std_ext_adv
, see the code in the file
"string.cpp"
.
The example string type
typedef std_ext_adv::sequence<char> StringChar ;
can be regarded as an improved std::vector<char>
container that
supports logarithmic time insert and erase operations for a single element.
In addition to this, an algorithm using this container obtains efficient
logarithmic time splice and split operations that eliminate unnecessary and
costly copy operations. This is why compared to std::string
,
StringChar
offers a set of much more efficient operations for strings.
A std::string
can be converted to a StringChar
through its constructor
StringChar string( std_str.begin(), std_str.end() ) ;
alternatively, it can be inserted directly before a required position
string . insert( pos, std_str.begin(), std_str.end() ) ;
Similar conversions can be used to return a processed string or text
from StringChar
to std::string
.
The example functions in the file "string.cpp"
demonstrate string operations based on the efficient move semantics algorithms.
These algorithms do not copy and do not erase strings and substrings involved.
They just move a range of characters from one string into another.
Thus, each of the three operations discussed below has logarithmic
computational complexity.
The string concatenation is just a special case of the splice operation:
string_a . splice ( string_a.end() , string_b ) ;
A substring can be easily obtained using the member function spit()
:
string . split( pos_a , pos_b , sub_string ) ;
The replace substring operation applies both of the discussed operations:
pos = string . split ( pos_a , pos_b , sub_str ) ; pos = string . splice( pos , sub_str_new ) ;
The split()
function extracts a substring to be replaced,
then the splice()
function moves a new substring at
the position of the extracted substring. Note that this example code
uses updated iterators returned by StringChar
member functions.
This code addresses the problem of invalidation of iterators of
array based containers, for more details see the section
Random access iterators of array based B+ trees.
In a text editor StringChar
can represent a long text.
This type of a string efficiently supports all main editing operations:
cut, copy, paste, delete, find, replace, etc. The high performance and
space optimized move semantics facilities are particularly beneficial for
undo and redo commands with large text blocks.
In practical applications it is important to minimize the number of conversions
between different types of strings to obtain the best performance. Unfortunately,
the STL design for strings is inconsistent with other standard containers,
since many string algorithms are implemented as member functions of
the class std::basic_string
. The same algorithms using iterator ranges
could be directly applied to both standard strings and strings based on advanced
data structures. These variants of string algorithms would considerably reduce
the frequency of conversions to and from std::string
and
improve performance of user algorithms.
The example in the file "interval.cpp"
demonstrates how to use
the new associative containers with random access iterators to find the total
number of intersections between an input interval and a sequence of intervals.
The main advantage of the algorithm developed for this example is its low computational cost. It finds any number of intersections in O(log N) time, where N is the number of intervals in a sequence. Note that this algorithm does not return a result list with all intersected intervals. This is a different problem. An algorithm for this problem has the computational cost of at least the number of intersections, which can be much greater than O(log N).
The algorithm of this example has been developed for semi-open intervals with
endpoints [a, b)
, a<=b
:
class Interval { public: explicit Interval ( int _a=0 , int _b=0 ) : a ( _a ) , b ( _b ) { if ( b < a ) std::swap ( a , b ) ; } int A ( ) const { return a ; } int B ( ) const { return b ; } private: int a ; int b ; } ;
The type VectInterval
typedef std::vector<Interval> VectInterval ;
represents a collection of intervals. In generic algorithms a collection, such as
VectInterval
, can store either unordered or ordered objects of any size
and any type, provided that each object represents an interval.
In order to test the correctness of the new efficient algorithm, the example includes linear algorithm of counting of intersections of intervals
int CountIntersections ( Interval const & interval_x , VectInterval const & vect_interval ) ;
For the method of linear counting, a result of the intersection of two arbitrary intervals is determined by the function:
bool Intersect ( Interval const & x , Interval const & y ) { return ( x.A() < y.B() ) && ( y.A() < x.B() ) ; }
The method of fast counting of all intersections between an input interval and a sequence
of intervals is based on a simple fact. The total number of intervals in the sequence is
equal to the sum of two numbers of intervals that intersect and do not intersect input
interval x
. For semi-open intervals with endpoints [a, b)
,
the total number of intersections n_x
can be calculated by the formula:
n_x = n - n_a - n_b ;
where n
is the total number of intervals in the sequence, n_a
is the number of intervals in the sequence with upper endpoint b
such that ( i.b <= x.a )
, n_b
is the number of intervals in
the sequence with lower endpoint a
such that ( i.a >= x.b )
.
Both n_a
and n_b
are the numbers of intervals that do not
intersect input interval x
.
The efficiency of this method is defined by the efficiency of the calculation of values of
n_a
and n_b
, since the total number of intervals in a sequence
n
is obtained in constant time.
If the intervals and their endpoints are stored in unordered containers, the required numbers
n_a
and n_b
can be obtained in linear time only.
In order to improve the performance, the method uses two ordered sequences: the first one stores
the lower endpoints from every interval, while the second one stores the upper endpoints.
The ordered sequences support the search for boundaries of subsets of intervals with
logarithmic time. The calculation of n_a
and n_b
through random access
iterators pointing to the boundaries of the subsets has constant cost. This is why the performance
of this method is logarithmic in the worst case and does not depend on the total number of
intersections of intervals.
The namespace std_ext_adv
offers associative containers with random access
iterators required for the implementation of the fast counting of intersections of intervals.
The type MultiSetInt
typedef std_ext_adv::multiset<int> MultiSetInt ;
represents a collection of intervals ordered by the lower or upper endpoint of an interval.
The associative containers of the namespace std_ext_adv
support
logarithmic time search for boundaries of the required subsets through
the member functions lower_bound()
and upper_bound()
along with constant time counting of intervals in these subsets through
random access iterators. The efficient algorithm of counting of
intersections with logarithmic running time is implemented in the method:
int CountIntersections ( Interval const & interval_x , MultiSetInt const & mset_a , MultiSetInt const & mset_b ) { int n = mset_a . size ( ) ; int n_a = mset_b . upper_bound ( interval_x.A() ) - mset_b . begin ( ) ; int n_b = mset_a . end ( ) - mset_a . lower_bound ( interval_x.B() ) ; int count = n - n_a - n_b ; return count ; }
This example algorithm of the fast counting of intersections of intervals
can be extended for even more advanced applications. This can be achieved
through associative containers of the namespace std_ext_adv
,
which support random access iterators and the efficient algorithm
accumulate()
. For any required subset of intervals, an algorithm
based on these containers can obtain not only the number of intervals, but
also the total time, the mean value and standard deviation. The computational
cost of obtaining of all of these parameters is logarithmic.
This example is quite simple and useful in numerous problems. It also demonstrates how the performance of an algorithm based on new containers is improved compared to C++ standard containers and algorithms.
For any container, which uses the efficient algorithm accumulate()
of the class bp_tree_array_acc
, the mean value of N
consecutive elements can be determined as shown in this demo code:
sum = data_container . accumulate ( pos_a , pos_b , 0 ) ; n = pos_b - pos_a ; mean = sum / n ;
This method has the total cost of only O(log N) in the worst case.
The mean value requires the calculation of two values: the sum of elements and
the number of elements.
The efficient algorithm accumulate()
finds the first
value for O(log N) steps.
The cost associated with the second value is negligible, since random
access iterators allow the determination of the number of consecutive
elements in constant time.
The support of random access iterators is an important detail in achieving
the low computational cost of the calculation of the mean value. If, for a example, a
container would implement a fast algorithm accumulate()
and bidirectional
iterators, the total cost of the calculation of the mean value would increase to
O(N) as a result of counting elements by the method
n = std::distance ( pos_a , pos_b ) ;
For the C++ standard containers the best performance of the calculation of
the mean value can be achieved with std::vector
, since it supports
random access iterators. A method based on this container has total cost O(N),
which is the cost of calculating the sum of elements using the STL method
sum = std::accumulate ( pos_a , pos_b , 0 ) ;
The rest of this section discusses several practical applications of sequences based on
the class bp_tree_array_acc
of the namespace std_ext_adv
.
These examples demonstrate that the containers with random access iterators and
the efficient algorithm accumulate()
provide very efficient facilities
for analysis of data.
The common feature of these examples using fast algorithm accumulate()
is the calculation of sums and mean values of several parameters of a sequence of objects.
In these applications, the most straightforward method is to create a container with the fast
algorithm accumulate()
for every parameter to be processed by a user algorithm.
The examples demonstrate how to solve a problem using only one container for all parameters to be summed up in a user algorithm. In many practical applications, this can be achieved with a user defined type, which stores values of all parameters required in the algorithm. The method based on a single container with a user defined type for all parameters provides at least two advantages: optimized space usage and improved structure of a user algorithm.
The demo code shows how this method works with the containers of the namespace
std_ext_adv
using both the efficient and the standard algorithm
accumulate()
. The results of these algorithms are compared to test
the correctness of the implementation.
All the example algorithms based on containers of the namespace std_ext_adv
with the efficient algorithm accumulate()
have the same theoretical performance.
In every example, a value of a sum is calculated in logarithmic time and a number of elements
within a specified range - in constant time.
The code in the file "rectangle_area.cpp"
demonstrates how to use the fast algorithm
accumulate()
to calculate sums and mean values of several parameters of
a sequence of rectangles: the width, length, perimeter and area. This example includes
the numerical integration as a particular case.
In the group of examples using one container with the efficient summation algorithm, this example is the most advanced and illustrative in terms of implementation details. This is why it is given the most detailed consideration and explanation.
The class RectArea
has three data members to store and calculate sums of
all the required parameters:
class RectArea { ... int width ; int length ; int area ; } ;
The width and length of a rectangle must be provided by a user algorithm.
The area of the rectangle is calculated automatically using the provided
values of the width and length. Storing the area value is an important detail
of this programming solution. In many similar applications involving
the processing of rectangles, it is sufficient to store in the class
Rectangle
values of only two independent attributes:
class Rectangle { ... double length ; double width ; double Area ( ) const { return length*width ; } } ;
The value of the derived attribute area can be calculated in constant time using the length and width of the rectangle. Within this alternative approach, the area value is not stored in order to save space.
The list of data members of the class RectArea
cannot be reduced to
two independent parameters only, if a user algorithm calculates the sum of areas.
In the general case, this value cannot be obtained from the sums of the lengths
and widths. On the other hand, the sum and mean value of the perimeter can be
calculated using the length and width sums. Thus, this parameter does not require
a special data member in the class RectArea
.
When specifying the interface of the class RectArea
, it is necessary
to define a number of arithmetic operators. A B+ tree supporting the efficient
algorithm accumulate()
requires that a user defined type overload
the following operators:
class RectArea { ... RectArea & operator += ( const RectArea & x ) ; RectArea & operator -= ( const RectArea & x ) ; RectArea operator + ( const RectArea & x ) ; RectArea operator - ( const RectArea & x ) ; } ;
Through these operators, implementation functions of the B+ tree update
cached data in internal nodes when the tree is modified and support
the efficient algorithm accumulate()
. Overloading four
operators is a relatively strict requirement, since the summation of
elements with the standard algorithm std::accumulate()
requires overloading only one binary operator+
.
The discussed data members and arithmetic operators of the class RectArea
meet the minimum requirements for an element of a sequence with the efficient algorithm
accumulate()
for this example. In practical applications, this class can have
other data members and interface operations.
The demo code shows two methods for the calculation of the sums.
For efficient calculation in logarithmic running time, a user algorithm
should call the member function accumulate()
:
sum_rect_area = seqceRectArea . accumulate ( pos_a , pos_b , sum_rect_area_0 ) ;
The standard algorithm std::accumulate()
obtains the same result in linear time:
sum_rect_area = std::accumulate ( pos_a , pos_b , sum_rect_area_0 ) ;
The second method can be helpful at the development stage of a project to test the correctness of the design and implementation of new classes and algorithms.
The values of sums of specific parameters of a sequence of rectangles can now be
obtained through the interface member functions of the class RectArea
:
sum_width = sum_rect_area . Width ( ) ; sum_length = sum_rect_area . Length( ) ; sum_area = sum_rect_area . Area ( ) ;
The number of elements in the range of calculations is obtained in constant time through the distance between random access iterators:
n = pos_b - pos_a ;
The mean values of the width, length and area are obtained from the corresponding sums:
mean_width = sum_width / n ; mean_length = sum_length / n ; mean_area = sum_area / n ;
As it has been discussed above the main feature of the selected method is
the calculation of several sums using one container with the efficient
algorithm accumulate()
. Despite only the width and length of
a rectangle are independent parameters, the class RectArea
has a special data member to store the area too. In contrast to the area
calculation, the mean value of the perimeter does not require storing
a special sum as a data member of the class RectArea
.
It can be derived from results obtained for the width and length
using their sums or mean values, e.g.:
mean_perimeter = 2.0 * ( mean_width + mean_length ) ;
This example can be used to implement the rectangle method of the numerical integration
of a function. The approximate value of the definite integral is provided by the sum of
rectangle areas sum_area
. The width of a rectangle is a variable parameter,
which means that a user algorithm can sample the function with both equal and variable
steps between abscissas of data points. In the simplest cases when all data points are
equally spaced it is sufficient to store in a container only area values without using
the class RectArea
.
The code of this example can be also adapted to support the other widely used integration method of the trapezoidal rule. The high accuracy methods of the numerical integration sum up values of a function multiplied by their weights. The example of the weighted mean value, which is discussed below, shows how the sums can be calculated in logarithmic time instead of linear.
The important feature of the containers of the namespace std_ext_adv
is the low cost of all the basic operations. The computer algorithms of the numerical
integrations based on these containers can take advantage of the fast update operations
in order to efficiently find the best approximation of a function. The insertion of
new data or interpolation points improves the accuracy of the approximation.
The deletion of redundant points reduces the size of approximation data and
saves space.
The mean value and the standard deviation are the key parameters in the statistical
analysis of data. Practical applications processing large and huge data sets demand
the most efficient algorithms for calculating these parameters. This example shows
how to use one container with the efficient algorithm accumulate()
to obtain these two important parameters for any number of consecutive elements
of a sequence.
In this example, see file "standard_deviation.cpp"
,
the type of an element of a sequence with the efficient algorithm
accumulate()
is represented by the class ElementValue
:
class ElementValues { public: explicit ElementValues ( int v=0 ) ; int Value ( ) const ; int ValueSquared ( ) const ; ElementValues & operator += ( const ElementValues & x ) ; ElementValues & operator -= ( const ElementValues & x ) ; ElementValues operator + ( const ElementValues & x ) ; ElementValues operator - ( const ElementValues & x ) ; private: int value ; int value_squared ; } ;
This class stores both the value of an element and its squared value. A user algorithm provides only the value of an element. The squared value is calculated and updated automatically through the constructor and operators of this class.
From an implementation point of view, this example algorithm can be regarded as a simplified variant of the algorithm processing parameters of a sequence of rectangles. In fact, the previous solution can support the calculations of mean and standard deviation values of elements provided that both the width and the length of a rectangle, more exactly square, represent the value of an element and the area represents the squared value of the element.
The example code shows how to obtain the sum of values of elements and
the sum of squared values using both the standard and efficient algorithm
accumulate()
. These calculations apply the efficient algorithm:
sum_elem_values = seqce_values . accumulate ( pos_a , pos_b , sum_elem_values_0 ) ; sum_x = sum_elem_values . Value ( ) ; sum_x_2 = sum_elem_values . ValueSquared ( ) ;
The mean value and standard deviation are derived from the obtained sums and the number of elements:
n = pos_b - pos_a ; mean = sum_x/n ; variance = sum_x_2/n - mean*mean ; deviation = sqrt ( variance ) ;
The efficient calculation of the mean value and standard deviation provides the following interesting result. The standard deviation is a measure of the distribution of data. If the value of this parameter is zero, then all the elements of the sequence have the same value. This conclusion is particularly important for unordered sequences. The calculation of the sums of values and squared values has logarithmic cost. Hence, the efficient calculation of the standard deviation enables the user algorithm to test if any number N of the consecutive elements are all equal in O(log N) time.
In practical applications, it is necessary to minimize numerical errors of floating data types. Some improvement can be achieved by eliminating the division by the number of elements from the variance calculations. In this case, the test is reduced to the comparison of the sums of values and squared values:
// test if all elements have the same value if ( n*sum_x_2 == sum_x*sum_x ) ...
This method can be suitable for integral types and user defined types based on integral types.
Note also that for ordered sequences, the test if all the elements
in a range have the same value is trivial. It only compares the values of
elements at two specified positions. For non-empty semi-open range
[pos_a, pos_b)
, the test is:
if ( *pos_a == *(pos_b-1) ) ...
This test has constant cost. For an unordered sequence, without the efficient
algorithm accumulate()
the test takes linear time.
The weighted mean value is an important characteristic and method for
the analysis of large data sets. For histogram data the weight parameter
represents a frequency of a value. For a large data set with pre-calculated
mean values of subsets the weight represents a number of elements in a data subset.
This parameter significantly improves the running time of the calculation of
the mean value of the whole data set. With weights and mean values of subsets
the time reduces from the total number of elements to the total number of
subsets only. The example in file "weighted_mean.cpp"
demonstrates how to improve the performance of calculations of the weighted
mean value even further using a sequence with the efficient algorithm
accumulate()
. The running time of this algorithm is logarithmic
function of the number of subsets.
The type of a container element is declared and defined in
the class WeightedValue
. It includes the three data members
to store the value of an element, its weight and contribution,
which is defined as the product of the value by its weight:
class WeightedValue { ... int value ; int weight ; int contribution ; } ;
The value of an element and its weight must be provided by a user algorithm. The contribution of the value is automatically calculated and updated using the value and its weight.
The comparison shows that this example has a very close similarity with the example of the calculation of the mean values of parameters for a sequence of rectangles. When the length, width and area of a rectangle represent the value, weight and contribution, respectively, of an element, the examples become almost identical. This fact suggests that in practical applications, code reuse can be achieved through the parameterization of algorithms. This fact also allows us to omit the discussion of many implementation details of this example.
The major specific feature of this example is that the calculation of the weighted mean value uses two accumulated sums of the contributions and weights:
mean_weighted = sum_contribution / sum_weight ;
The arithmetic mean value is derived from the sum of all values and the total number of the values. The arithmetic mean is a special case of the weighted mean when every weight is equal to one. However, the total number of elements does not require any special summation, since it can be determined in constant time through random access iterators as discussed above in the example "Mean value and standard deviation".
It is interesting to compare the performance improvement of the standard
and new methods of the weighted mean value in the calculation of
the mean value of a data set. For example, if a data set contains
1,000,000
elements arranged into 1,000
subsets
with pre-calculated mean values, then the standard algorithm improves
the performance by the factor 1,000
. This improvement is substantial
for any practical application. The new efficient algorithm accumulate()
has logarithmic running time. For this reason its performance improvement
is not so significant as for linear algorithms. For the same example, it is
log(1,000,000)/log(1,000)
, which gives the factor 2.0
.
Revised 11 November, 2012
Copyright © 2011-2012
Vadim Stadnik
<EMAIL_ADDRESS>Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)


output¶
The output package holds python modules, files and folders needed for export out of teaser.
ModelicaTemplate folder¶
This folder holds a collection of Modelica model templates. Currently we support the MultiZoneBuilding of AixLib, including boundary conditions and an optional central air handlingunit. Further the given examples of Annex library are supported, which can be then used for own purposes.
TextTemplate folder¶
This folder holds one template for the output of model parameters in a text file. Currently only the two element model is supported, but more are to come.


Full cycle iOS Application Development: Refine features, Wireframe, Design, Development, Testing, Launch.
Free consulting mobile app business & startup idea.
Proactive communication, always touchable, guarantee 24-hour responding.
Dedicated working, actively in giving idea, solution and suggestion.
Experience in idea building, willing to spend time and effort on startup as a team player.
Open to share business mindset, opensource world and valuable information.
Freelancer is a free bootstrap theme created by Start Bootstrap. The download includes the complete source files including HTML, CSS, and JavaScript as well as optional LESS stylesheets for easy customization.
Whether you're a student looking to showcase your work, a professional looking to attract clients, or a graphic artist looking to share your projects, this template is the perfect starting point!


There are dozens of different potato variables. They are usually described as early, second early and maincrop


Native Windows GUI: Features
Almost all of the features of native-windows-gui are behimd feature flags, but by default it includes everything.
In order to cut the compile time, specify
default-features=false
in Cargo.toml. Ex:
native-windows-gui = {
version="1",
default-features=false,
features = [
"extern-canvas", "frame", "raw-win-handle",
"listbox", "flexbox", "cursor",
"animation-timer"
]
}
Feature list
Here is a list of all the features in NWG
- animation-timer: A custom timer to handle animations and timeout
- clipboard: Enable the clipboard features
- color-dialog: Enable the color dialog
- combobox: The combobox control
- cursor: The GlobalCursor utility to handle the windows mouse cursor
- datetime-picker: The datetime picker control
- dynamic_layout: Enable dynamic layout
- embed-resource: Enable the EmbedResource resource
- extern-canvas: The extern canvas control. It can be used as a target to render from external API (like opengl or Vulkan)
- file-dialog: The file dialog resource
- flexbox: The flexbox layout
- font-dialog: The font dialog resource
- frame: The frame control. A optionally bordered rect that can contain children.
- high-dpi: Enable high-dpi functions
- image-decoder: Add lots of supported image format to Bitmap and the ImageDecoder resource
- image-list: Adds icons to controls that implement them (listview, tabs, etc)
- list-view: The list view control
- listbox: The list box control
- menu: Menu bar & menu item for top level window. Also includes popup menus
- message-window: An invisible window that processes messages in the background
- no-styling: Disable automatic style (ex: if you specify stylling in the manifest)
- notice: An obejct to wake up a gui thread from another thread
- number-select: A custom control to select numbers
- progress-bar: The progress bar control
- raw-win-handle: Implement the raw-window-handle for extern canvas and window
- rich-textbox: A rich text box control
- scroll-bar: A scrollbar control
- status-bar: A satus bar control
- tabs: The tabs container control
- textbox: A simple text box
- timer: DEPRECATED. Use animation-timer instead.
- tooltip: The Tooltip control. It manages tooltip for 1 or more gui controls
- trackbar: The trackbar control
- tray-notification: Windows tray notification
- tree-view: The treeview control
- tree-view-iterator: An iterator for the tree view control
- winnls: Internationalization windows service ex: The month name locale example


Why Carrie Lam should consider amnesty for arrested protesters
by Andy LooFollowing the District Council elections on Sunday, when voters were able to let off steam through the ballot box, street clashes between protesters and the police are likely to ease off for a brief period of time.
I believe the SAR government should seize this precious window of opportunity to do something to resolve the current crisis.
After the DC race, the administration can announce that it is going to set up an independent commission of inquiry, which will be headed by a highly credible figure and will start working on January 1, 2020.
The chief executive can also make further concessions by offering amnesty to those who committed crimes related to the protests before New Year’s Eve, thereby allowing the city to make a fresh start in 2020.
Although the independent commission of inquiry itself will not be pressing criminal charges, it can enhance public confidence in the fairness of the prosecution brought by the Department of Justice against arrested the protesters.
Instead of just allowing the tit-for-tat between the police and the protesters to go on, I believe my suggestion of granting pardon to those who have violated the law before the arrival of January 1, 2020 can reduce the level of animosity between the two sides.
It is inevitable that some people would be fiercely opposed to establishing an independent inquiry and offering amnesty to protesters.
But if the chief executive is not sure which side she should listen to, there is one thing she must keep in mind: whoever advised her to press ahead with the Fugitive Offenders Ordinance in the first place, which has proven a political misjudgment of catastrophic proportions, must be wrong.
This article appeared in the Hong Kong Economic Journal on Nov 22
Translation by Alan Lee
– Contact us at<EMAIL_ADDRESS>JC/CG


Composite parallel
Parallel nodes inherit from the composite base node class.
Parallel nodes execute each of their children in order from left to right every time they are run. Parallel nodes can be configured to succeed when a certain number of children succeed or fail when a certain number of children fail.
Functions
| constructor (config) | Constructs a parallel node class instance. |
| reset () | Resets the parallel node's state and other stateful properties for itself and all of it's children. |
| on_step (...) | The main method that handles the processing for this parallel node. |
| check_target () | Counts the number of child nodes that succeeded, failed, or currently running still. |
| on_finish [abstract] | Optionally overidden and called when the node finishes processing. |
Tables
| config | Configuration table passed into the constructor function. |
Functions
- constructor (config)
-
Constructs a parallel node class instance.
Parameters:
- reset ()
- Resets the parallel node's state and other stateful properties for itself and all of it's children.
- on_step (...)
-
The main method that handles the processing for this parallel node. Each child is executed in order until the
pass or fail target count is reached.
Parameters:
- ... Any parameters passed to the node's run method
Returns:
-
A string representing the enum behaviors.states of "running", "success", or "failed".
- check_target ()
-
Counts the number of child nodes that succeeded, failed, or currently running still. If strategy is
PASS_CERTAIN then when the number of successes is equal to or greater than the target count, this parallel
node succeeds. If all children have finished and the target count has not been reached, this parallel
node will fail. If strategy is FAIL_CERTAIN then when the number of failed child nodes is equal to or
greater than the target count, then this parallel node fails. if all the children have
finished and the target count has not been reached, this parallel node will succeed.
Returns:
-
A string representing the enum behaviors.states of "running", "success", or "failed".
- on_finish [abstract]
-
Optionally overidden and called when the node finishes processing.
Parameters:
- ... Any parameters passed to the node's run method
Tables
- config
-
Configuration table passed into the constructor function.
Fields:
- children tab The instantiated child nodes of this parallel node.
- strategy enum The behaviors.parallel_strategy enum for pass certain or fail certain.
- target_count number The target number of successes or fails of child nodes.


Methods
connect()
connect Connect your client to the broker
disconnect(force, cb)
disconnect disconnect from the broker
Parameters:
| Name | Type | Description |
|---|---|---|
force |
Boolean | force disconnect. Default: false |
cb |
function | Callback function the be called after disconnect. Default: undefined |
init(_user, _pw, _clientId, _broker, _topics)
init Initialize the library
Parameters:
| Name | Type | Description |
|---|---|---|
_user |
String | The user name at your broker. Default: try |
_pw |
String | The password at your broker. Default: try |
_clientId |
String | The name you want to be displayed with: Default: mqttControlsClient |
_broker |
String | The borker to connect to. Default: brker.shiftr.io |
_topics |
Object | Topics to subscribe and th publish to. Currently one one per publish and subscribe. Default `{'subscribe':'/output/#','publih':'/input/'}` |
mqttControls()
mqttControls The main object. Everything else is a child
publish()
publish Start publishing in an interval to your broker this is more for testing then for real usage.
reconnect()
reconnect Reconnect to your broker
send(message, topic)
Send one signal to the borker
Parameters:
| Name | Type | Description |
|---|---|---|
message |
String | The message to send. Default: `{'hello mqtt-controls'}` |
topic |
String | The topic to send to. Default: is `topics = {'subscribe':'/output/#','publih':'/input/'}` |
subscribe()
subscribe Subscribes to your topics
unpublish()
unpublish Stop publishing to the broker
unsubscribe()
unsubscribe Unsubscribes from your topics
mqttControls.unsubscribe()


{% extends "base.html" %} {% block content %}
We offer all sorts of health care diagnosis to help speed up your process LIKE


Preston woman hosting bumper raffle in aid of Lostock Hall hospice that cares for her dad
by Laura LongworthA Preston woman is hosting a raffle with more than £1,300 worth of prizes in aid of the Lostock Hall hospice that cares for her dad.
Tricia Hall decided to raise money for St Catherine's Hospice in Lostock Lane after becoming a full-time carer to her 90-year-old parents, who have both suffered a stroke.
The charity began giving her dad 24-hour high-level care at home in November last year, as well as helping Tricia, her mum and their own carers.
This will be Tricia's last raffle of the year for the charity and prizes include Pandora jewellery, a Marc Jacobs Daisy gift set, a family photo shoot and a pair of Virgin train tickets.
The cost per ticket is £5.
For payment details, contact Tricia by searching for Fundraising for St Catherine's Hospice Lostock Hall on Facebook.


Business Logic, Digital Forgery, Twitter Demetricator, and ML for Kids The Business Logic of Silicon Valley (Cory Doctorow) -- Selling hardware does not have exponential growth potential, because people only need so many sex toys, and really successful models are likely to be cloned or imitated, driving down the price. For a "smart" sex toy startup to cash out its investors, it will need to have a second, much more profitable business, and that, inevitably, is private data about sex toy users. Commoditization of AI, Digital Forgery, and the End of Trust -- Once tools for fabrication become a commodity, the effects will be more dramatic than the current phenomenon of fake news. In the tech circles, the issue are discussed only at a philosophical level; no clear solution is known at present time. This post discusses pros and cons of two classes of potential solutions: digital signatures and learning-based detection systems. Twitter Demetricator -- a Chrome interface that hides all the gamification numbers in Twitter. Machine Learning for Kids -- Each project is a stand-alone activity, written to last for a single lesson, and will guide children to create a game or interactive project that demonstrates a real-world use of artificial intelligence and machine learning. Continue reading Four short links: 28 March 2018.


My report page in the course websoft
This is my report-page in the course. This page contains a presentation of myself. Keep this site updated all through the course and hand it in, for grading, in the end of the course.
So, a presentation might be in order.
My name is Ivan Marosan. I was born in a little town known as Hofors in Gästrikland, Sweden. When I was about 7~8 years old my parents moved down from Hofors to Eslöv before finally settling down in Lund. I've lived in Lund for all my time since then.
I'm currently a student on Högskolan Kristianstad pursuing a degree in Computer Science. Prior to that I used to study the teacher's program before dropping out from it since I didn't find the job appealing after 3 years of study. When I'm not studying one can find me working in an orthopedical clinic to make some extra money
My hobbies are what one would say your typical nerd hobbies. I like video games, and traditional games like card games and board games. One of my favourite games is Magic the Gathering where I do play on a semi-competitive level.
Besides that I'm always up to help people and I do try my best to stay in touch with people.


Book
Send parcels
Pricing
MY MENU
Bookings
Deliveries
Profile
Logout
Send IT
Send parcels
You will be Notified when your parcel is delivered or canlced


CSU Fullerton ACM-W supports, celebrates, and advocates for the full engagement, education, and opportunities of women in all aspects of the computing field. We endeavor to provide a wide range of programs and services to students and advance, in the larger community, the contributions of technical women students.
Find Out MoreThe goal of ACM-W is to get more girls interested in computer science by exposing them to programming at a young age. ACM-W on the California State University of Fullerton campus has only been around for barely a year. However, the collaboration with the Girl Scouts of Orange County and the funding from Google gives ACM-W the opportunity to accomplish this goal. We are excited for this opportunity to influence young girls about programming and increase the number of girls in computer science.
Join Now!President
Sara’s enthusiastic demeanor radiates wherever she goes and with whatever she does. She enjoys sharing her creative passions of programming and song writing with others. Learning from others and combining perspectives brings her great joy.
Vice President
Leigh loves reading books, watching horror movies, and listening to pop&rock music. Like many children destined to become computer scientists, when she found something she liked she went full throttle ahead: she once watched the movie "School of Rock” more than 5 times in the same day.
Treasurer
Diana is such a caring and friendly person that it is no surprise that she would like to make software for hospitals. Those who meet Diana are immediately taken by her friendly demeanor. In her free time, she likes to express herself through art by painting beautiful pictures of her favorite Disney characters.
Secretary
Justine is dependable, friendly, and hardworking. She is passionate about creatively solving problems with computer science and hopes to someday incorporate her passion into solving environmental issues. A fun fact about her is she's ambidextrous, she colors with her left hand and writes with her right.
The purpose of ACM-W in this event is to work with the Girl Scouts of Orange County and teach girls about the world of engineering. The goal of ACM-W is to get more girls interested in computer science by exposing them to programming at a young age.
During the Spring 2016 semester, the ACM-W Chapter at CSUF and the Girl Scouts of Orange County participated in a mentorship program called Creative Coding. With sponsorship from IgniteCS at Google, they explored Turtle Graphics and Ozobots.
We host several interesting events every month.
It’s countdown to Girls in Tech Catalyst! TedX style presentation, cocktail parties, networking andmore! You’ll be in the company of Aaron Levie (CEO, Box), Jennifer Hyman (founder & CEO, Rent the Runway), Lisa Falzone (founder & CEO, Revel) and more.
Save your seat now! http://bit.ly/2kyfgFX


|
BitShares-Core
6.1.0
BitShares blockchain implementation and command-line interface software
|
#include <chain_parameters.hpp>
Classes | |
| struct | ext |
Public Member Functions | |
| const fee_schedule & | get_current_fees () const |
| fee_schedule & | get_mutable_fees () |
| void | validate () const |
| chain_parameters () | |
| chain_parameters (const chain_parameters &other) | |
| chain_parameters (chain_parameters &&other) | |
| chain_parameters & | operator= (const chain_parameters &other) |
| chain_parameters & | operator= (chain_parameters &&other) |
| uint16_t | get_market_fee_network_percent () const |
| uint16_t | get_maker_fee_discount_percent () const |
Public Attributes | |
| std::shared_ptr< const fee_schedule > | current_fees |
| current schedule of fees More... | |
| uint8_t | block_interval = GRAPHENE_DEFAULT_BLOCK_INTERVAL |
| interval in seconds between blocks More... | |
| uint32_t | maintenance_interval = GRAPHENE_DEFAULT_MAINTENANCE_INTERVAL |
| interval in sections between blockchain maintenance events More... | |
| uint8_t | maintenance_skip_slots = GRAPHENE_DEFAULT_MAINTENANCE_SKIP_SLOTS |
| number of block_intervals to skip at maintenance time More... | |
| uint32_t | committee_proposal_review_period = GRAPHENE_DEFAULT_COMMITTEE_PROPOSAL_REVIEW_PERIOD_SEC |
| minimum time in seconds that a proposed transaction requiring committee authority may not be signed, prior to expiration More... | |
| uint32_t | maximum_transaction_size = GRAPHENE_DEFAULT_MAX_TRANSACTION_SIZE |
| maximum allowable size in bytes for a transaction More... | |
| uint32_t | maximum_block_size = GRAPHENE_DEFAULT_MAX_BLOCK_SIZE |
| maximum allowable size in bytes for a block More... | |
| uint32_t | maximum_time_until_expiration = GRAPHENE_DEFAULT_MAX_TIME_UNTIL_EXPIRATION |
| maximum lifetime in seconds for transactions to be valid, before expiring More... | |
| uint32_t | maximum_proposal_lifetime = GRAPHENE_DEFAULT_MAX_PROPOSAL_LIFETIME_SEC |
| maximum lifetime in seconds for proposed transactions to be kept, before expiring More... | |
| uint8_t | maximum_asset_whitelist_authorities = GRAPHENE_DEFAULT_MAX_ASSET_WHITELIST_AUTHORITIES |
| maximum number of accounts which an asset may list as authorities for its whitelist OR blacklist More... | |
| uint8_t | maximum_asset_feed_publishers = GRAPHENE_DEFAULT_MAX_ASSET_FEED_PUBLISHERS |
| the maximum number of feed publishers for a given asset More... | |
| uint16_t | maximum_witness_count = GRAPHENE_DEFAULT_MAX_WITNESSES |
| maximum number of active witnesses More... | |
| uint16_t | maximum_committee_count = GRAPHENE_DEFAULT_MAX_COMMITTEE |
| maximum number of active committee_members More... | |
| uint16_t | maximum_authority_membership = GRAPHENE_DEFAULT_MAX_AUTHORITY_MEMBERSHIP |
| largest number of keys/accounts an authority can have More... | |
| uint16_t | reserve_percent_of_fee = GRAPHENE_DEFAULT_BURN_PERCENT_OF_FEE |
| the percentage of the network's allocation of a fee that is taken out of circulation More... | |
| uint16_t | network_percent_of_fee = GRAPHENE_DEFAULT_NETWORK_PERCENT_OF_FEE |
| percent of transaction fees paid to network More... | |
| uint16_t | lifetime_referrer_percent_of_fee = GRAPHENE_DEFAULT_LIFETIME_REFERRER_PERCENT_OF_FEE |
| percent of fee which should go to lifetime referrer More... | |
| uint32_t | cashback_vesting_period_seconds = GRAPHENE_DEFAULT_CASHBACK_VESTING_PERIOD_SEC |
| time after cashback rewards are accrued before they become liquid More... | |
| share_type | cashback_vesting_threshold = GRAPHENE_DEFAULT_CASHBACK_VESTING_THRESHOLD |
| the maximum cashback that can be received without vesting More... | |
| bool | count_non_member_votes = true |
| set to false to restrict voting privlegages to member accounts More... | |
| bool | allow_non_member_whitelists = false |
| true if non-member accounts may set whitelists and blacklists; false otherwise More... | |
| share_type | witness_pay_per_block = GRAPHENE_DEFAULT_WITNESS_PAY_PER_BLOCK |
| CORE to be allocated to witnesses (per block) More... | |
| uint32_t | witness_pay_vesting_seconds = GRAPHENE_DEFAULT_WITNESS_PAY_VESTING_SECONDS |
| vesting_seconds parameter for witness VBO's More... | |
| share_type | worker_budget_per_day = GRAPHENE_DEFAULT_WORKER_BUDGET_PER_DAY |
| CORE to be allocated to workers (per day) More... | |
| uint16_t | max_predicate_opcode = GRAPHENE_DEFAULT_MAX_ASSERT_OPCODE |
| predicate_opcode must be less than this number More... | |
| share_type | fee_liquidation_threshold = GRAPHENE_DEFAULT_FEE_LIQUIDATION_THRESHOLD |
| value in CORE at which accumulated fees in blockchain-issued market assets should be liquidated More... | |
| uint16_t | accounts_per_fee_scale = GRAPHENE_DEFAULT_ACCOUNTS_PER_FEE_SCALE |
| number of accounts between fee scalings More... | |
| uint8_t | account_fee_scale_bitshifts = GRAPHENE_DEFAULT_ACCOUNT_FEE_SCALE_BITSHIFTS |
| number of times to left bitshift account registration fee at each scaling More... | |
| uint8_t | max_authority_depth = GRAPHENE_MAX_SIG_CHECK_DEPTH |
| extension< ext > | extensions |
Definition at line 46 of file chain_parameters.hpp.
| graphene::protocol::chain_parameters::chain_parameters | ( | ) |
Definition at line 7 of file chain_parameters.cpp.
| graphene::protocol::chain_parameters::chain_parameters | ( | const chain_parameters & | other | ) |
Definition at line 12 of file chain_parameters.cpp.
| graphene::protocol::chain_parameters::chain_parameters | ( | chain_parameters && | other | ) |
Definition at line 64 of file chain_parameters.cpp.
|
inline |
Definition at line 50 of file chain_parameters.hpp.
| uint16_t graphene::protocol::chain_parameters::get_maker_fee_discount_percent | ( | ) | const |
If maker_fee_discount_percent
in extensions is valid, return the value it contains, otherwise return 0
Definition at line 122 of file chain_parameters.cpp.
| uint16_t graphene::protocol::chain_parameters::get_market_fee_network_percent | ( | ) | const |
If market_fee_network_percent
in extensions is valid, return the value it contains, otherwise return 0
Definition at line 116 of file chain_parameters.cpp.
|
inline |
Definition at line 51 of file chain_parameters.hpp.
| chain_parameters & graphene::protocol::chain_parameters::operator= | ( | const chain_parameters & | other | ) |
Definition at line 19 of file chain_parameters.cpp.
| chain_parameters & graphene::protocol::chain_parameters::operator= | ( | chain_parameters && | other | ) |
Definition at line 71 of file chain_parameters.cpp.
| void graphene::protocol::chain_parameters::validate | ( | ) | const |
Definition at line 81 of file chain_parameters.cpp.
| uint8_t graphene::protocol::chain_parameters::account_fee_scale_bitshifts = GRAPHENE_DEFAULT_ACCOUNT_FEE_SCALE_BITSHIFTS |
number of times to left bitshift account registration fee at each scaling
Definition at line 79 of file chain_parameters.hpp.
| uint16_t graphene::protocol::chain_parameters::accounts_per_fee_scale = GRAPHENE_DEFAULT_ACCOUNTS_PER_FEE_SCALE |
number of accounts between fee scalings
Definition at line 78 of file chain_parameters.hpp.
| bool graphene::protocol::chain_parameters::allow_non_member_whitelists = false |
true if non-member accounts may set whitelists and blacklists; false otherwise
Definition at line 72 of file chain_parameters.hpp.
| uint8_t graphene::protocol::chain_parameters::block_interval = GRAPHENE_DEFAULT_BLOCK_INTERVAL |
interval in seconds between blocks
Definition at line 53 of file chain_parameters.hpp.
| uint32_t graphene::protocol::chain_parameters::cashback_vesting_period_seconds = GRAPHENE_DEFAULT_CASHBACK_VESTING_PERIOD_SEC |
time after cashback rewards are accrued before they become liquid
Definition at line 69 of file chain_parameters.hpp.
| share_type graphene::protocol::chain_parameters::cashback_vesting_threshold = GRAPHENE_DEFAULT_CASHBACK_VESTING_THRESHOLD |
the maximum cashback that can be received without vesting
Definition at line 70 of file chain_parameters.hpp.
| uint32_t graphene::protocol::chain_parameters::committee_proposal_review_period = GRAPHENE_DEFAULT_COMMITTEE_PROPOSAL_REVIEW_PERIOD_SEC |
minimum time in seconds that a proposed transaction requiring committee authority may not be signed, prior to expiration
Definition at line 56 of file chain_parameters.hpp.
| bool graphene::protocol::chain_parameters::count_non_member_votes = true |
set to false to restrict voting privlegages to member accounts
Definition at line 71 of file chain_parameters.hpp.
| std::shared_ptr<const fee_schedule> graphene::protocol::chain_parameters::current_fees |
current schedule of fees
using a shared_ptr breaks the circular dependency created between operations and the fee schedule
Definition at line 49 of file chain_parameters.hpp.
Definition at line 90 of file chain_parameters.hpp.
| share_type graphene::protocol::chain_parameters::fee_liquidation_threshold = GRAPHENE_DEFAULT_FEE_LIQUIDATION_THRESHOLD |
value in CORE at which accumulated fees in blockchain-issued market assets should be liquidated
Definition at line 77 of file chain_parameters.hpp.
| uint16_t graphene::protocol::chain_parameters::lifetime_referrer_percent_of_fee = GRAPHENE_DEFAULT_LIFETIME_REFERRER_PERCENT_OF_FEE |
percent of fee which should go to lifetime referrer
Definition at line 68 of file chain_parameters.hpp.
| uint32_t graphene::protocol::chain_parameters::maintenance_interval = GRAPHENE_DEFAULT_MAINTENANCE_INTERVAL |
interval in sections between blockchain maintenance events
Definition at line 54 of file chain_parameters.hpp.
| uint8_t graphene::protocol::chain_parameters::maintenance_skip_slots = GRAPHENE_DEFAULT_MAINTENANCE_SKIP_SLOTS |
number of block_intervals to skip at maintenance time
Definition at line 55 of file chain_parameters.hpp.
| uint8_t graphene::protocol::chain_parameters::max_authority_depth = GRAPHENE_MAX_SIG_CHECK_DEPTH |
Definition at line 80 of file chain_parameters.hpp.
| uint16_t graphene::protocol::chain_parameters::max_predicate_opcode = GRAPHENE_DEFAULT_MAX_ASSERT_OPCODE |
predicate_opcode must be less than this number
Definition at line 76 of file chain_parameters.hpp.
| uint8_t graphene::protocol::chain_parameters::maximum_asset_feed_publishers = GRAPHENE_DEFAULT_MAX_ASSET_FEED_PUBLISHERS |
the maximum number of feed publishers for a given asset
Definition at line 62 of file chain_parameters.hpp.
| uint8_t graphene::protocol::chain_parameters::maximum_asset_whitelist_authorities = GRAPHENE_DEFAULT_MAX_ASSET_WHITELIST_AUTHORITIES |
maximum number of accounts which an asset may list as authorities for its whitelist OR blacklist
Definition at line 61 of file chain_parameters.hpp.
| uint16_t graphene::protocol::chain_parameters::maximum_authority_membership = GRAPHENE_DEFAULT_MAX_AUTHORITY_MEMBERSHIP |
largest number of keys/accounts an authority can have
Definition at line 65 of file chain_parameters.hpp.
| uint32_t graphene::protocol::chain_parameters::maximum_block_size = GRAPHENE_DEFAULT_MAX_BLOCK_SIZE |
maximum allowable size in bytes for a block
Definition at line 58 of file chain_parameters.hpp.
| uint16_t graphene::protocol::chain_parameters::maximum_committee_count = GRAPHENE_DEFAULT_MAX_COMMITTEE |
maximum number of active committee_members
Definition at line 64 of file chain_parameters.hpp.
| uint32_t graphene::protocol::chain_parameters::maximum_proposal_lifetime = GRAPHENE_DEFAULT_MAX_PROPOSAL_LIFETIME_SEC |
maximum lifetime in seconds for proposed transactions to be kept, before expiring
Definition at line 60 of file chain_parameters.hpp.
| uint32_t graphene::protocol::chain_parameters::maximum_time_until_expiration = GRAPHENE_DEFAULT_MAX_TIME_UNTIL_EXPIRATION |
maximum lifetime in seconds for transactions to be valid, before expiring
Definition at line 59 of file chain_parameters.hpp.
| uint32_t graphene::protocol::chain_parameters::maximum_transaction_size = GRAPHENE_DEFAULT_MAX_TRANSACTION_SIZE |
maximum allowable size in bytes for a transaction
Definition at line 57 of file chain_parameters.hpp.
| uint16_t graphene::protocol::chain_parameters::maximum_witness_count = GRAPHENE_DEFAULT_MAX_WITNESSES |
maximum number of active witnesses
Definition at line 63 of file chain_parameters.hpp.
| uint16_t graphene::protocol::chain_parameters::network_percent_of_fee = GRAPHENE_DEFAULT_NETWORK_PERCENT_OF_FEE |
percent of transaction fees paid to network
Definition at line 67 of file chain_parameters.hpp.
| uint16_t graphene::protocol::chain_parameters::reserve_percent_of_fee = GRAPHENE_DEFAULT_BURN_PERCENT_OF_FEE |
the percentage of the network's allocation of a fee that is taken out of circulation
Definition at line 66 of file chain_parameters.hpp.
| share_type graphene::protocol::chain_parameters::witness_pay_per_block = GRAPHENE_DEFAULT_WITNESS_PAY_PER_BLOCK |
CORE to be allocated to witnesses (per block)
Definition at line 73 of file chain_parameters.hpp.
| uint32_t graphene::protocol::chain_parameters::witness_pay_vesting_seconds = GRAPHENE_DEFAULT_WITNESS_PAY_VESTING_SECONDS |
vesting_seconds parameter for witness VBO's
Definition at line 74 of file chain_parameters.hpp.
| share_type graphene::protocol::chain_parameters::worker_budget_per_day = GRAPHENE_DEFAULT_WORKER_BUDGET_PER_DAY |
CORE to be allocated to workers (per day)
Definition at line 75 of file chain_parameters.hpp.


<wintitle>
The <wintitle>
element can be used to mark up names of windows or
dialogs, or other user interface elements at the same level of grouping, including wizard
titles, wizard page titles, and window pane titles. This element is part of the DITA user
interface domain, a special set of DITA elements designed to document user interface tasks,
concepts and reference information.
Category: User interface elements


SCAPE Planning Suite - #{viewWorkflow.currentView.name}
#{viewWorkflow.currentView.name}
In the experiments, the preservation alternatives are applied to the previous defined sample records. The
results of the experiments are later evaluated against the goals and requirements of the objective tree.


public class EnhancedPatternLayout extends Layout
A flexible layout configurable with pattern string. The goal of this class
is to format
a LoggingEvent
and return the results
in a StringBuffer
. The format of the result depends on the
conversion pattern.
The conversion pattern is closely related to the conversion pattern of the printf function in C. A conversion pattern is composed of literal text and format control expressions called conversion specifiers.
Note that you are free to insert any literal text within the conversion pattern.
Each conversion specifier starts with a percent sign (%) and is followed by optional format modifiers and a conversion character. The conversion character specifies the type of data, e.g. category, priority, date, thread name. The format modifiers control such things as field width, padding, left and right justification. The following is a simple example.
Let the conversion pattern be "%-5p [%t]: %m%n" and assume that the log4j environment was set to use a EnhancedPatternLayout. Then the statements
Category root = Category.getRoot(); root.debug("Message 1"); root.warn("Message 2");would yield the output
DEBUG [main]: Message 1 WARN [main]: Message 2
Note that there is no explicit separator between text and conversion specifiers. The pattern parser knows when it has reached the end of a conversion specifier when it reads a conversion character. In the example above the conversion specifier %-5p means the priority of the logging event should be left justified to a width of five characters. The recognized conversion characters are
| Conversion Character | Effect | |
|---|---|---|
| c | Used to output the category of the logging event. The
category conversion specifier can be optionally followed by
NameAbbreviator pattern.
For example, for the category name "alpha.beta.gamma" the pattern %c{2} will output the last two elements ("beta.gamma"), %c{-2} will remove two elements leaving "gamma", %c{1.} will output "a.b.gamma". |
|
| C | Used to output the fully qualified class name of the caller issuing the logging request. This conversion specifier can be optionally followed by precision specifier, that is a decimal constant in brackets. | Used to output the category of the logging event. The
category conversion specifier can be optionally followed by
NameAbbreviator pattern.
For example, for the category name "alpha.beta.gamma" the pattern %c{2} will output the last two elements ("beta.gamma"), %c{-2} will remove two elements leaving "gamma", %c{1.} will output "a.b.gamma". WARNING Generating the caller class information is slow. Thus, its use should be avoided unless execution speed is not an issue. |
| d | Used to output the date of
the logging event. The date conversion specifier may be
followed by a set of braces containing a
date and time pattern strings SimpleDateFormat ,
ABSOLUTE, DATE or ISO8601
and a set of braces containing a time zone id per
TimeZone.getTimeZone(String) .
For example, %d{HH:mm:ss,SSS},
%d{dd MMM yyyy HH:mm:ss,SSS},
%d{DATE} or %d{HH:mm:ss}{GMT+0}. If no date format specifier is given then
ISO8601 format is assumed.
|
|
| F | Used to output the file name where the logging request was
issued.
WARNING Generating caller location information is extremely slow and should be avoided unless execution speed is not an issue. | |
| l | Used to output location information of the caller which generated
the logging event.
The location information depends on the JVM implementation but usually consists of the fully qualified name of the calling method followed by the callers source the file name and line number between parentheses. The location information can be very useful. However, its generation is extremely slow and should be avoided unless execution speed is not an issue. |
|
| L | Used to output the line number from where the logging request
was issued.
WARNING Generating caller location information is extremely slow and should be avoided unless execution speed is not an issue. | |
| m | Used to output the application supplied message associated with the logging event. | |
| M | Used to output the method name where the logging request was
issued.
WARNING Generating caller location information is extremely slow and should be avoided unless execution speed is not an issue. | |
| n | Outputs the platform dependent line separator character or
characters.
This conversion character offers practically the same performance as using non-portable line separator strings such as "\n", or "\r\n". Thus, it is the preferred way of specifying a line separator. | |
| p | Used to output the priority of the logging event. | |
| r | Used to output the number of milliseconds elapsed since the construction of the layout until the creation of the logging event. | |
| t | Used to output the name of the thread that generated the logging event. | |
| x | Used to output the NDC (nested diagnostic context) associated with the thread that generated the logging event. | |
| X |
Used to output the MDC (mapped diagnostic context) associated
with the thread that generated the logging event. The X
conversion character can be followed by the key for the
map placed between braces, as in %X{clientNumber} where
See |
|
| properties |
Used to output the Properties associated
with the logging event. The properties
conversion word can be followed by the key for the
map placed between braces, as in %properties{application} where
|
|
| throwable |
Used to output the Throwable trace that has been bound to the LoggingEvent, by default this will output the full trace as one would normally find by a call to Throwable.printStackTrace(). %throwable{short} or %throwable{1} will output the first line of stack trace. throwable{none} or throwable{0} will suppress the stack trace. %throwable{n} will output n lines of stack trace if a positive integer or omit the last -n lines if a negative integer. If no %throwable pattern is specified, the appender will take responsibility to output the stack trace as it sees fit. |
|
| % | The sequence %% outputs a single percent sign. |
By default the relevant information is output as is. However, with the aid of format modifiers it is possible to change the minimum field width, the maximum field width and justification.
The optional format modifier is placed between the percent sign and the conversion character.
The first optional format modifier is the left justification flag which is just the minus (-) character. Then comes the optional minimum field width modifier. This is a decimal constant that represents the minimum number of characters to output. If the data item requires fewer characters, it is padded on either the left or the right until the minimum width is reached. The default is to pad on the left (right justify) but you can specify right padding with the left justification flag. The padding character is space. If the data item is larger than the minimum field width, the field is expanded to accommodate the data. The value is never truncated.
This behavior can be changed using the maximum field width modifier which is designated by a period followed by a decimal constant. If the data item is longer than the maximum field, then the extra characters are removed from the beginning of the data item and not from the end. For example, it the maximum field width is eight and the data item is ten characters long, then the first two characters of the data item are dropped. This behavior deviates from the printf function in C where truncation is done from the end.
Below are various format modifier examples for the category conversion specifier.
| Format modifier | left justify | minimum width | maximum width | comment |
|---|---|---|---|---|
| %20c | false | 20 | none | Left pad with spaces if the category name is less than 20 characters long. |
| %-20c | true | 20 | none | Right pad with spaces if the category name is less than 20 characters long. |
| %.30c | NA | none | 30 | Truncate from the beginning if the category name is longer than 30 characters. |
| %20.30c | false | 20 | 30 | Left pad with spaces if the category name is shorter than 20 characters. However, if category name is longer than 30 characters, then truncate from the beginning. |
| %-20.30c | true | 20 | 30 | Right pad with spaces if the category name is shorter than 20 characters. However, if category name is longer than 30 characters, then truncate from the beginning. |
Below are some examples of conversion patterns.
The above text is largely inspired from Peter A. Darnell and Philip E. Margolis' highly recommended book "C -- a Software Engineering Approach", ISBN 0-387-97389-3.
| 限定符和类型 | 字段和说明 |
|---|---|
protected int |
BUF_SIZE
已过时。
since 1.3
|
static java.lang.String |
DEFAULT_CONVERSION_PATTERN
Default pattern string for log output.
|
protected int |
MAX_CAPACITY
已过时。
since 1.3
|
static java.lang.String |
PATTERN_RULE_REGISTRY
Customized pattern conversion rules are stored under this key in the
LoggerRepository object store. |
static java.lang.String |
TTCC_CONVERSION_PATTERN
A conversion pattern equivalent to the TTCCCLayout.
|
LINE_SEP, LINE_SEP_LEN
| 构造器和说明 |
|---|
EnhancedPatternLayout()
Constructs a EnhancedPatternLayout using the DEFAULT_LAYOUT_PATTERN.
|
EnhancedPatternLayout(java.lang.String pattern)
Constructs a EnhancedPatternLayout using the supplied conversion pattern.
|
| 限定符和类型 | 方法和说明 |
|---|---|
void |
activateOptions()
Activates the conversion pattern.
|
protected PatternParser |
createPatternParser(java.lang.String pattern)
Returns PatternParser used to parse the conversion string.
|
java.lang.String |
format(LoggingEvent event)
Formats a logging event to a writer.
|
java.lang.String |
getConversionPattern()
Returns the value of the ConversionPattern option.
|
boolean |
ignoresThrowable()
Will return false if any of the conversion specifiers in the pattern
handles
Exceptions . |
void |
setConversionPattern(java.lang.String conversionPattern)
Set the ConversionPattern option.
|
getContentType, getFooter, getHeader
public static final java.lang.String DEFAULT_CONVERSION_PATTERN
public static final java.lang.String TTCC_CONVERSION_PATTERN
protected final int BUF_SIZE
protected final int MAX_CAPACITY
public static final java.lang.String PATTERN_RULE_REGISTRY
LoggerRepository
object store.public EnhancedPatternLayout()
public EnhancedPatternLayout(java.lang.String pattern)
pattern
- conversion pattern.public void setConversionPattern(java.lang.String conversionPattern)
conversionPattern
- conversion pattern.public java.lang.String getConversionPattern()
protected PatternParser createPatternParser(java.lang.String pattern)
public void activateOptions()
public java.lang.String format(LoggingEvent event)
public boolean ignoresThrowable()
Exceptions
.ignoresThrowable
在类中 Layout
Copyright © 1999-2015 Apache Software Foundation. All Rights Reserved.


Our objective is to build a solution that rely on nobody. You will own your bookmark and your interface.
Inspiration comes in many ways and you like to save everything from.
Inspiration comes in many ways and you like to save everything from.
Inspiration comes in many ways and you like to save everything from.
Inspiration comes in many ways and you like to save everything from.
Inspiration comes in many ways and you like to save everything from. Our web app is working on all differents devices, you will have access whenever you want to your inspiration.
Inspiration comes in many ways and you like to save everything from. Our web app is working on all differents devices, you will have access whenever you want to your inspiration.
Helps you keep your inspiration in the same place from pictures to links, texts and colors. Inspiration comes in many ways and you like to save
icons
Andrew Hellon
Enter you email address to be notified of the launch


CommandLineArgumentsPicoContainer is a special type of PicoContainer that processes the arguments passed into from the command line, and sets them up as configuration for other components.
Here is an example of how to use CommandLineArgumentsPicoContainer to map command line arguments as configuration for a component, with parameter names as the bindings.
Consider this component:
public class BigFatComponent { URL spellWebService; int timeout; public BigFatComponent(String spellingWebServiceURL, int timeout) throws MalformedURLExeption { this.spellWebService = new URL(spellingWebServiceURL); this.timeout = timeout; } public String toString() { return "URL=" + spellWebService + ", timeout=" + timeout; } // other methods }
For automatic binding of command line arguments to parameter names of the component:
public static void main(String[] args) { PicoContainer argsContainer = new CommandLineArgumentsPicoContainer(args); MutablePicoContainer mpc = new DefaultPicoContainer(argsContainer); mpc.as(Characteristics.USE_NAMES).addComponent(BigFatComponent.class); Object o = mpc.getComponent(BigFatComponent.class); } ... java -jar myAppJar.jar -cp picocontainer-2.0.jar timeout=100 spellingWebServiceURL=http://ws.com/someService.wsdl
Here is another manual use forcing an association between a item in the properties file, and the relative position of a parameter in the constructor:
mpc.addComponent(BigFatComponent.class, ConfigParameter("config1"), ConfigParameter("moreConfig")); ... java -jar myAppJar.jar -cp picocontainer-2.0.jar config1=http://ws.com/someService.wsd moreConfig=100
Type conversion is automatic in many cases. Properties in a properties file are clearly strings. Parameters can be any of:
CommandLineArgumentsPicoContainer can be part of a tree of containers. It makes sense, of course, being more near the root of that tree.


This document contains the full list of documents being managed as “Web Platform Specs”, each with a minimal abstract and links to their variants.
The manner in which Web standards are developed today is often daunting to newcomers, most notably to Web developers whose input is sorely needed in order to build a better Web.
The goal of this project is to fix this. The Web development community, and open source people in general, have over time developed work modes that are highly effective and can sustain both high quality and openness to contributions. There is no reason why such methods cannot be applied to open standards just as well, and that is what we endeavour to do.
It is still the early days and pretty much every part of the system has rough edges — but every part is also being improved. If you want to join the fun, we welcome contributions on all aspects.
The URL Standard defines URLs, domains, IP addresses, the
application/x-www-form-urlencoded
format, and their API.
Defines implementer requirements for HTML feature mapping to Accessibility APIs by reference to ARIA role, states and properties, and conformance requirements for the use of ARIA in HTML.
Defines the web developer (author) rules (conformance requirements) for the use of ARIA attributes on SVG 1.1 elements. It also defines the requirements for Conformance Checking tools.
Defines a sectioning element (panel) which contains a heading, built-in optional controls, and a generic single select managing container for these (panelset) which can be styled to any number of common visual forms (tabsets, accordions, carousels, decks) while retaining common semantic information and abilities.
Specifications get added to this document through
pull requests. If you wish to publish a
fork of an existing specification, simply add an entry to the

When your PR is reviewed, in order to ensure that your fork is automatically published
whenever you make changes to it you just need to create a Web hook in your GitHub repository
that points to http://publican.berjon.com/hook
. Once your PR is accepted, the
WebSpecs index will be updated and your specification will be published (and republished
automatically if you’ve got the hook setup).
All contributions to this document are made under the W3C Software License and Notice.


Assignments
Here are my assignments
Block One
The HTML <figure >Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.
Block Two
The HTML <figure >Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.
Block Three
The HTML <figure >Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.
Small Block
A small amount of text.
More Text
Foo.This is a new paragraph.