My Top Skills
The technology is changing everyday rapidly. I like to read and think about the new technology out there. Look at it from a different prespective and find a way in creating my own way to develop the new technology that can benifit the world.
When I see data, I see beauty. I like to break down the data into pieces. Analyze and visualize the data and predict its future behaviour
Adobe Photoshop, Illustration, and Animation
I thank all my mentors, teachers, professors, and coaches for inspired me to become the person who I am today. A special thank for my dad (my backbone), and my family for supporting me and for helping me to learn and overcome any struggles I faced.
Articles and Thoughts
Season Achievemnts by Trinity College Squash Team
Feel free to leave me a message for an opportunity or anything I can help with.


about me
Hello, I am Marcel. Born in the early 80s and currently on my way to become a web developer. Before that I worked in marketing and e-commerce, where I had early contact with HTML and CSS.
life career
- Apprenticeship as retail salesman
- Further training as e-commerce manager
- Advanced knowledge in Google cosmus
- Self-employed t-shirt designer
private
- Fifa
- Netflix
- LED technology
- Computers in general
- Walking in the rain (rather at night)
contact
contact me marcel@klebauter.de


LOGIN
Open menu
Home
All Events
Online Events
Offline Events
Testimonials
Speakers
Contact
Events
All Events
Online Events
Offline Events
Testimonials
Speakers
Contact
LOGIN
Offline Events
Look for exciting events around you to attend
Upcoming
E-Summit'19 Workshops
19-20 Jan, 2019
Starts 9:00PM
₹1200
TechFest 2019
21 Mar, 2019
Starts 9:00PM
Free
TechFest: Innovation Challenge
12 May, 2019
7:00AM - 9:00PM
₹500
Past
HiddenRamp: WebBattle
28 Feb, 2019
Starts 9:00PM
Free
HiddenRamp: WebBattle
28 Feb, 2019
Starts 9:00PM
Free
HiddenRamp: WebBattle
28 Feb, 2019
Starts 9:00PM
Free
HiddenRamp: WebBattle
28 Feb, 2019
Starts 9:00PM
Free
HiddenRamp: WebBattle
28 Feb, 2019
Starts 9:00PM
Free
HiddenRamp: WebBattle
28 Feb, 2019
Starts 9:00PM
Free


Preparation time
less than 30 mins
Cooking time
10 to 30 mins
Serves
Serves 1
Preheat the oven to 180C/350F/Gas 4.
Heat the oil in an ovenproof frying pan and sear the chicken breast on all sides until golden-brown, about 4-5 minutes.
Add the garlic cloves, chopped chillies and honey to the pan, stir, and transfer to the oven to cook for 8-10 minutes, or until the chicken is completely cooked through.
To serve, place the chicken onto a serving plate with the green beans and drizzle over the pan juices. Scatter with toasted almonds and serve.


Ask me not what I know.ALBANY
Exit
Go after her: she's desperate; govern her.EDMUND
What you have charged me with, that have I done;EDGAR
And more, much more; the time will bring it out:
'Tis past, and so am I. But what art thou
That hast this fortune on me? If thou'rt noble,
I do forgive thee.
Let's exchange charity.EDMUND
I am no less in blood than thou art, Edmund;
If more, the more thou hast wrong'd me.
My name is Edgar, and thy father's son.
The gods are just, and of our pleasant vices
Make instruments to plague us:
The dark and vicious place where thee he got
Cost him his eyes.
Thou hast spoken right, 'tis true;ALBANY
The wheel is come full circle: I am here.
Methought thy very gait did prophesyEDGAR
A royal nobleness: I must embrace thee:
Let sorrow split my heart, if ever I
Did hate thee or thy father!
Worthy prince, I know't.ALBANY
Where have you hid yourself?EDGAR
How have you known the miseries of your father?
By nursing them, my lord. List a brief tale;EDMUND
And when 'tis told, O, that my heart would burst!

That we the pain of death would hourly die
Rather than die at once!--taught me to shift
Into a madman's rags; to assume a semblance
That very dogs disdain'd: and in this habit
Met I my father with his bleeding rings,
Their precious stones new lost: became his guide,
Led him, begg'd for him, saved him from despair;
Never,--O fault!--reveal'd myself unto him,
Until some half-hour past, when I was arm'd:
Not sure, though hoping, of this good success,
I ask'd his blessing, and from first to last
Told him my pilgrimage: but his flaw'd heart,
Alack, too weak the conflict to support!
'Twixt two extremes of passion, joy and grief,
Burst smilingly.

If there be more, more woeful, hold it in;EDGAR
For I am almost ready to dissolve,
Hearing of this.
This would have seem'd a periodALBANY
To such as love not sorrow; but another,
To amplify too much, would make much more,
And top extremity.
Whilst I was big in clamour came there in a man,
Who, having seen me in my worst estate,
Shunn'd my abhorr'd society; but then, finding
Who 'twas that so endured, with his strong arms
He fastened on my neck, and bellow'd out
As he'ld burst heaven; threw him on my father;
Told the most piteous tale of Lear and him
That ever ear received: which in recounting
His grief grew puissant and the strings of life
Began to crack: twice then the trumpets sounded,
And there I left him tranced.
But who was this?EDGAR
Kent, sir, the banish'd Kent; who in disguiseGentleman
Follow'd his enemy king, and did him service
Improper for a slave.

Who dead? speak, man.Gentleman
Your lady, sir, your lady: and her sisterEDMUND
By her is poisoned; she hath confess'd it.
I was contracted to them both: all threeEDGAR
Now marry in an instant.
Here comes Kent.ALBANY
Produce their bodies, be they alive or dead:KENT
This judgment of the heavens, that makes us tremble,
Touches us not with pity.
Exit Gentleman
Enter KENT
O, is this he?
The time will not allow the compliment
Which very manners urges.
I am comeALBANY
To bid my king and master aye good night:
Is he not here?
Great thing of us forgot!KENT
Speak, Edmund, where's the king? and where's Cordelia?
See'st thou this object, Kent?
The bodies of GONERIL and REGAN are brought in
Alack, why thus?EDMUND
Yet Edmund was beloved:ALBANY
The one the other poison'd for my sake,
And after slew herself.
Even so. Cover their faces.EDMUND
I pant for life: some good I mean to do,ALBANY
Despite of mine own nature. Quickly send,
Be brief in it, to the castle; for my writ
Is on the life of Lear and on Cordelia:
Nay, send in time.
Run, run, O, run!EDGAR
To who, my lord? Who hath the office? sendEDMUND
Thy token of reprieve.
Well thought on: take my sword,ALBANY
Give it the captain.
Haste thee, for thy life.EDMUND
Exit EDGAR
He hath commission from thy wife and meALBANY
To hang Cordelia in the prison, and
To lay the blame upon her own despair,
That she fordid herself.
The gods defend her! Bear him hence awhile.KING LEAR
EDMUND is borne off
Re-enter KING LEAR, with CORDELIA dead in his arms; EDGAR, Captain, and others following
Howl, howl, howl, howl! O, you are men of stones:KENT
Had I your tongues and eyes, I'ld use them so
That heaven's vault should crack. She's gone for ever!
I know when one is dead, and when one lives;
She's dead as earth. Lend me a looking-glass;
If that her breath will mist or stain the stone,
Why, then she lives.
Is this the promised endEDGAR
Or image of that horror?ALBANY
Fall, and cease!KING LEAR
This feather stirs; she lives! if it be so,KENT
It is a chance which does redeem all sorrows
That ever I have felt.

Cordelia, Cordelia! stay a little. Ha!
What is't thou say'st? Her voice was ever soft,
Gentle, and low, an excellent thing in woman.
I kill'd the slave that was a-hanging thee.
'Tis true, my lords, he did.KING LEAR
Did I not, fellow?KENT
I have seen the day, with my good biting falchion
I would have made them skip: I am old now,
And these same crosses spoil me. Who are you?
Mine eyes are not o' the best: I'll tell you straight.
If fortune brag of two she loved and hated,KING LEAR
One of them we behold.
This is a dull sight. Are you not Kent?KENT
The same,KING LEAR
Your servant Kent: Where is your servant Caius?
He's a good fellow, I can tell you that;KENT
He'll strike, and quickly too: he's dead and rotten.
No, my good lord; I am the very man,--KING LEAR
I'll see that straight.KENT
That, from your first of difference and decay,KING LEAR
Have follow'd your sad steps.
You are welcome hither.KENT
Nor no man else: all's cheerless, dark, and deadly.KING LEAR
Your eldest daughters have fordone them selves,
And desperately are dead.
Ay, so I think.ALBANY
He knows not what he says: and vain it isEDGAR
That we present us to him.
Very bootless.Captain
Enter a Captain
Edmund is dead, my lord.ALBANY
That's but a trifle here.KING LEAR
You lords and noble friends, know our intent.
What comfort to this great decay may come
Shall be applied: for us we will resign,
During the life of this old majesty,
To him our absolute power:
To EDGAR and KENT
you, to your rights:
With boot, and such addition as your honours
Have more than merited. All friends shall taste
The wages of their virtue, and all foes
The cup of their deservings. O, see, see!
  Thou'lt come no more,
Never, never, never, never, never!
Pray you, undo this button: thank you, sir.
Do you see this? Look on her, look, her lips,
Look there, look there!
Dies
He faints!
He is gone, indeed.KENT
The wonder is, he hath endured so long:ALBANY
He but usurp'd his life.
Bear them from hence. Our present businessKENT
Is general woe.
To KENT and EDGAR
Friends of my soul, you twain
Rule in this realm, and the gored state sustain.
I have a journey, sir, shortly to go;ALBANY
My master calls me, I must not say no.
The weight of this sad time we must obey;
Speak what we feel, not what we ought to say.
The oldest hath borne most: we that are young
Shall never see so much, nor live so long.
Exeunt, with a dead march


(Route : Settings Menu, Preferences Command)
This tab page allows you to set preferences for reading messages in Ameol.
This is a Hot Spot image. Move your mouse pointer over the image
and when the mouse pointer changes to the shape of a hand click
the left mouse button once for extra help.


--- ---
This is the root UIRouter component, needed for initialising the router and setting up configuration properly.
Every other component from this library needs to be a descendant of <UIRouter>
, so ideally you want to use it as root of your app.
There are two ways to set up the router: you can either bootstrap it manually and pass the instance to the component, or pass the necessary information and let the component do it for you.
Setting up the router via this component is pretty straightforward:
const Home = () =>
Home
;
const states = [{
name: 'home',
component: Home,
url: '/home'
}];
const plugins = [pushStateLocationPlugin];
ReactDOM.render(
<UIRouter plugins={plugins} states={states}>
<UIView />
</UIRouter>,
document.getElementById('root'),
);
Optionally, you may want to access the router instance once to setup additional configuration, like registering TransitionHooks.
To do so, you may pass a config
function that will be called with the newly created router
instance as argument:
const config = router => {
// register home state as the intial one
router.urlService.rules.initial({ state: 'home' });
}
ReactDOM.render(
<UIRouter plugins={plugins} states={states} config={config}>
<UIView />
</UIRouter>,
document.getElementById('root'),
);
Alternatively you may setup the router manually (i.e. extracting the router configuration to another file). You can do that by creating a new instance of the router and pass it to the component, this way the component will skip the previous props and just use the provided instance.
NB: since you are manually bootstrapping the router, you must register the servicesPlugin as well as the location plugin of your choice (in this example the pushStateLocationPlugin).
const router = new UIRouterReact();
// activate plugins
router.plugin(servicesPlugin);
router.plugin(pushStateLocationPlugin);
// register states
router.stateRegistry.register(someState);
// start the router
router.start();
ReactDOM.render(
<UIRouter router={router}>
<UIView />
</UIRouter>,
document.getElementById("root")
);
Generated using TypeDoc
use useRouter or React.useContext(UIRouterContext)


new Vector2(x, y)
2D vector constructor.
This:
- {Vector2}
Parameters:
| Name | Type | Description |
|---|---|---|
x |
Number | X position |
y |
Number | Y position |
- Source:
Methods
(static) self.distanceTo(pos) → {Number}
Calculates the distance to another vector position.
Parameters:
| Name | Type | Description |
|---|---|---|
pos |
Vector2 | Position to calculate distance to. |
- Source:
Returns:
distance - Distance to other vector.
- Type
- Number
(static) self.getPos() → {Object}
Gets the full vector position.
- Source:
Returns:
position - An object containing properties `x` and `y`, representing vector positions.
- Type
- Object
(static) self.getX() → {Number}
Gets the vector x position.
- Source:
Returns:
x - Vector x position.
- Type
- Number
(static) self.getY() → {Number}
Gets the vector y position.
- Source:
Returns:
y - Vector y position.
- Type
- Number
(static) self.midpoint(pos) → {Vector2}
Finds the midpoint between this and another vector position.
Parameters:
| Name | Type | Description |
|---|---|---|
pos |
Vector2 | Position to calculate midpoint for. |
- Source:
Returns:
midpoint - Midpoint between this and another vector position.
- Type
- Vector2
(static) self.setPosition(position)
Sets the vector position.
Parameters:
| Name | Type | Description |
|---|---|---|
position |
Vector2 | Desired vector position |
- Source:
(static) self.setX(value)
Sets the vector's X position.
Parameters:
| Name | Type | Description |
|---|---|---|
value |
integer | Value of vector's X position. |
- Source:
(static) self.setY(value)
Sets the vector's Y position.
Parameters:
| Name | Type | Description |
|---|---|---|
value |
integer | Value of vector's Y position. |
- Source:
(static) self.translate(to) → {Object}
Performs a translation to another position.
Parameters:
| Name | Type | Description |
|---|---|---|
to |
Object | Position to translate the vector to. |
- Source:
Returns:
pos - Position the vector was translated to.
- Type
- Object


Markdown.css is better default styling for your Markdown files. It's heavily
inspired by the Space WordPress theme. This page is
itself a Markdown file using the markdown.css
stylesheet. View the source
code here.
View a sample file that implements most of the Markdown spec here.
Just add the following line to the top of your .markdown
files:
<link href="http://kevinburke.bitbucket.org/markdowncss/markdown.css" rel="stylesheet"></link>
For the markdown to parse correctly, you need to add the closing <link>
tag. This is not technically correct HTML, but it will parse in any browser.
Let's make the Web prettier. Add your own Markdown theme, or contribute to mine, here.


|
Bitshares-Core
3.0.0
BitShares blockchain implementation and command-line interface software
|
This class represents an account on the object graphAccounts are the primary unit of authority on the graphene system. Users must have an account in order to use assets, trade in the markets, vote for committee_members, etc. More...
#include <account_object.hpp>
Public Types | |
| typedef account_options | options_type |
Public Member Functions | |
| bool | has_special_authority () const |
| template<typename DB > | |
| const vesting_balance_object & | cashback_balance (const DB &db) const |
| bool | is_lifetime_member () const |
| bool | is_basic_account (time_point_sec now) const |
| bool | is_annual_member (time_point_sec now) const |
| bool | is_member (time_point_sec now) const |
| account_id_type | get_id () const |
Public Attributes | |
| time_point_sec | membership_expiration_date |
| account_id_type | registrar |
| The account that paid the fee to register this account. Receives a percentage of referral rewards. More... | |
| account_id_type | referrer |
| The account credited as referring this account. Receives a percentage of referral rewards. More... | |
| account_id_type | lifetime_referrer |
| The lifetime member at the top of the referral tree. Receives a percentage of referral rewards. More... | |
| uint16_t | network_fee_percentage = GRAPHENE_DEFAULT_NETWORK_PERCENT_OF_FEE |
| Percentage of fee which should go to network. More... | |
| uint16_t | lifetime_referrer_fee_percentage = 0 |
| Percentage of fee which should go to lifetime referrer. More... | |
| uint16_t | referrer_rewards_percentage = 0 |
| string | name |
| The account's name. This name must be unique among all account names on the graph. May not be empty. More... | |
| authority | owner |
| authority | active |
| account_options | options |
| account_statistics_id_type | statistics |
| flat_set< account_id_type > | whitelisting_accounts |
| flat_set< account_id_type > | blacklisting_accounts |
| optional< vesting_balance_id_type > | cashback_vb |
| special_authority | owner_special_authority = no_special_authority() |
| special_authority | active_special_authority = no_special_authority() |
| uint8_t | top_n_control_flags = 0 |
| optional< flat_set< asset_id_type > > | allowed_assets |
| set< account_id_type > | whitelisted_accounts |
| set< account_id_type > | blacklisted_accounts |
Static Public Attributes | |
| static const uint8_t | space_id = protocol_ids |
| static const uint8_t | type_id = account_object_type |
| static const uint8_t | top_n_control_owner = 1 |
| static const uint8_t | top_n_control_active = 2 |
This class represents an account on the object graph
Accounts are the primary unit of authority on the graphene system. Users must have an account in order to use assets, trade in the markets, vote for committee_members, etc.
Definition at line 147 of file account_object.hpp.
Definition at line 192 of file account_object.hpp.
|
inline |
Definition at line 260 of file account_object.hpp.
|
inline |
Definition at line 288 of file account_object.hpp.
|
inline |
Definition at line 253 of file account_object.hpp.
|
inline |
Definition at line 278 of file account_object.hpp.
|
inline |
Definition at line 272 of file account_object.hpp.
|
inline |
Definition at line 267 of file account_object.hpp.
|
inline |
Definition at line 283 of file account_object.hpp.
| authority graphene::chain::account_object::active |
The owner authority contains the hot keys of the account. This authority has control over nearly all operations the account may perform.
Definition at line 190 of file account_object.hpp.
| special_authority graphene::chain::account_object::active_special_authority = no_special_authority() |
Definition at line 236 of file account_object.hpp.
| optional< flat_set<asset_id_type> > graphene::chain::account_object::allowed_assets |
This is a set of assets which the account is allowed to have. This is utilized to restrict buyback accounts to the assets that trade in their markets. In the future we may expand this to allow accounts to e.g. voluntarily restrict incoming transfers.
Definition at line 251 of file account_object.hpp.
| set<account_id_type> graphene::chain::account_object::blacklisted_accounts |
Definition at line 218 of file account_object.hpp.
| flat_set<account_id_type> graphene::chain::account_object::blacklisting_accounts |
This is a set of all accounts which have 'blacklisted' this account. Blacklisting is only used in core validation for the purpose of forbidding accounts from holding and transacting in whitelisted assets. This account cannot update this set, and it will be preserved even if the account is transferred. Other accounts may add or remove their IDs from this set.
Definition at line 228 of file account_object.hpp.
| optional<vesting_balance_id_type> graphene::chain::account_object::cashback_vb |
Vesting balance which receives cashback_reward deposits.
Definition at line 233 of file account_object.hpp.
| account_id_type graphene::chain::account_object::lifetime_referrer |
The lifetime member at the top of the referral tree. Receives a percentage of referral rewards.
Definition at line 168 of file account_object.hpp.
| uint16_t graphene::chain::account_object::lifetime_referrer_fee_percentage = 0 |
Percentage of fee which should go to lifetime referrer.
Definition at line 173 of file account_object.hpp.
| time_point_sec graphene::chain::account_object::membership_expiration_date |
The time at which this account's membership expires. If set to any time in the past, the account is a basic account. If set to time_point_sec::maximum(), the account is a lifetime member. If set to any time not in the past less than time_point_sec::maximum(), the account is an annual member.
See is_lifetime_member, is_basic_account, is_annual_member, and is_member
Definition at line 161 of file account_object.hpp.
| string graphene::chain::account_object::name |
The account's name. This name must be unique among all account names on the graph. May not be empty.
Definition at line 179 of file account_object.hpp.
| uint16_t graphene::chain::account_object::network_fee_percentage = GRAPHENE_DEFAULT_NETWORK_PERCENT_OF_FEE |
Percentage of fee which should go to network.
Definition at line 171 of file account_object.hpp.
| account_options graphene::chain::account_object::options |
Definition at line 193 of file account_object.hpp.
| authority graphene::chain::account_object::owner |
The owner authority represents absolute control over the account. Usually the keys in this authority will be kept in cold storage, as they should not be needed very often and compromise of these keys constitutes complete and irrevocable loss of the account. Generally the only time the owner authority is required is to update the active authority.
Definition at line 187 of file account_object.hpp.
| special_authority graphene::chain::account_object::owner_special_authority = no_special_authority() |
Definition at line 235 of file account_object.hpp.
| account_id_type graphene::chain::account_object::referrer |
The account credited as referring this account. Receives a percentage of referral rewards.
Definition at line 166 of file account_object.hpp.
| uint16_t graphene::chain::account_object::referrer_rewards_percentage = 0 |
Percentage of referral rewards (leftover fee after paying network and lifetime referrer) which should go to referrer. The remainder of referral rewards goes to the registrar.
Definition at line 176 of file account_object.hpp.
| account_id_type graphene::chain::account_object::registrar |
The account that paid the fee to register this account. Receives a percentage of referral rewards.
Definition at line 164 of file account_object.hpp.
|
static |
Definition at line 150 of file account_object.hpp.
| account_statistics_id_type graphene::chain::account_object::statistics |
The reference implementation records the account's statistics in a separate object. This field contains the ID of that object.
Definition at line 197 of file account_object.hpp.
|
static |
Definition at line 244 of file account_object.hpp.
| uint8_t graphene::chain::account_object::top_n_control_flags = 0 |
This flag is set when the top_n logic sets both authorities, and gets reset when authority or special_authority is set.
Definition at line 242 of file account_object.hpp.
|
static |
Definition at line 243 of file account_object.hpp.
|
static |
Definition at line 151 of file account_object.hpp.
| set<account_id_type> graphene::chain::account_object::whitelisted_accounts |
Optionally track all of the accounts this account has whitelisted or blacklisted, these should be made Immutable so that when the account object is cloned no deep copy is required. This state is tracked for GUI display purposes.
TODO: move white list tracking to its own multi-index container rather than having 4 fields on an account. This will scale better because under the current design if you whitelist 2000 accounts, then every time someone fetches this account object they will get the full list of 2000 accounts.
Definition at line 217 of file account_object.hpp.
| flat_set<account_id_type> graphene::chain::account_object::whitelisting_accounts |
This is a set of all accounts which have 'whitelisted' this account. Whitelisting is only used in core validation for the purpose of authorizing accounts to hold and transact in whitelisted assets. This account cannot update this set, except by transferring ownership of the account, which will clear it. Other accounts may add or remove their IDs from this set.
Definition at line 205 of file account_object.hpp.


{% load static %}
It is good practice to extend templates from a `base` template which contains page layout. current base file is loaded from themes/vecto/base.html
themes/vecto/base.html
the vecto-theme default content


This module provides an API for managing and using timers.
- Note
- This is an initial version of the API that only provides support for relative timers (e.g., expires in 10 seconds). Absolute timers allow a specific time/date to be used, and will be supported in a future version of this API.
Creating/Deleting Timer Objects
Timers are created using le_timer_Create. The timer name is used for logging purposes only.
The following attributes of the timer can be set:
The repeat count defaults to 1, so that the timer is initially a one-shot timer. All the other attributes must be explicitly set. At a minimum, the interval must be set before the timer can be used. Note that these attributes can only be set if the timer is not currently running; otherwise, an error will be returned.
A timer is deleted using le_timer_Delete. If the timer is currently running, then it will be stopped first, before being deleted.
Using Timers
A timer can be started using le_timer_Start. If it's already running, then it won't be modified; instead an error will be returned. To restart a currently running timer, use le_timer_Restart.
A timer can be stopped using le_timer_Stop. If it's not currently running, an error will be returned, and nothing more will be done.
To determine if the timer is currently running, use le_timer_IsRunning.
When a timer expires, if the timer expiry handler is set by le_timer_SetHandler, the handler will be called with a reference to the expired timer. If additional data is required in the handler, le_timer_SetContextPtr can be used to set the appropriate context before starting the timer, and le_timer_GetContextPtr can be used to retrieve the context while in the handler.
The number of times that a timer has expired can be retrieved by le_timer_GetExpiryCount. This count is independent of whether there is an expiry handler for the timer.
Thread Support
A timer should only be used by the thread that created it. It's not safe for a thread to use or manipulate a timer that belongs to another thread. The timer expiry handler is called by the event loop of the thread that starts the timer.
See Event Loop API for details on running the event loop of a thread.
Fatal Errors
The process will exit under any of the following conditions:
- If an invalid timer object is given to:
Troubleshooting
Timers can be traced by enabling the log trace keyword "timers" in the "framework" component.
See Log Controls for more information.
Copyright (C) Sierra Wireless Inc. Use of this work is subject to license.


DSpace
Visualized
Home
DSpace
Visualization
Items submitted per month
Items per Collection
Users in this DSpace instance
Email distribution by domain
Language distribution by items
Configure
DSpace instance
Fun
SimpleREST URL
Set DSpace
Set fillcolor
Set strokecolor


Notification: Projects Initiated Successfully
Notification: Projects Not Initiated
Full Stack Web Developer


--- layout: default title: Get started permalink: /start/ ---
The fastest way to get started is to simply copy the HTML template below. There is no need to download anything as odin.css
can be served from the jsDelivr CDN. If you are integrating Odin into an existing project, make sure that you are including an HTML5 doctype declaration and a viewport meta tag so that your site will have proper responsive behaviors.
Any resets such as normalize.css
should be linked before odin.css
. Custom stylesheets and any stylesheets that override default Odin styling should be linked after. You will also need to link to odin.js
and JQuery if you plan on using slideout navbars or carousels. Otherwise, the JavaScript referrences can be deleted.
<!DOCTYPE html>
<html lang="en">
<head>
<!-- metadata -->
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<!-- page title -->
<title>Page Title</title>
<!-- styles -->
<link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/joncoop/odin@{{ site.version }}/dist/css/odin.min.css">
<!-- link to your custom stylesheets here -->
</head>
<body>
<!-- make your grid and add content here -->
<!-- include any javascript below this line -->
<script src="https://code.jquery.com/jquery-3.5.1.min.js"></script>
<script src="https://cdn.jsdelivr.net/gh/joncoop/odin@{{ site.version }}/dist/js/odin.min.js"></script>
</body>
</html>
If you'd rather have the code stored locally, then you can download unminified source. The framework is defined entirely in odin.css
. Interactive elements such as slide-out navigation and carousels require odin.js
which is reliant on jQuery.


Hi, i am pointblack. I love coding and blog about things i come across during my work as a developer. I share my findings to give something back to the community. When i dont code, i enjoy riding motorcycle and playing piano.
Github Profile.


This should be interpolated:
Username: @username
// V will NOT do interpolation inside
// V will interpolate the values here:
This should be interpolated too, because it is outside the script tag:
Year: @year
myint: @{benchmark_plot_data.myint(1)}
mydate: @{benchmark_plot_data.mydate()}


Toggle navigation
ACO Simulator
About
New Node
Move
Remove
Play
Step
Stop
Clear All
Ant Settings
Alpha
Beta
ρ
Q
Visualization
Show Ants
Yes
No
Show Pheromone
Yes
No
Show Best Solution
Yes
No
Node Color
Text Color
Animation Speed
×
Close
About
Implemented Algorithm
Ant System
M. Dorigo, V. Maniezzo & A. Colorni, Ant System: Optimization by a colony of cooperating agents. IEEE Transactions on Systems, Man, and Cybernetics-Part B, 26(1):29-41,1996.
IJ.10-SMC96.pdf
Source Code
https://github.com/thiagodnf/aco-simulator
Acknowledgement
GOES - Opitimization in Software Engineering Group
http://www.goes.uece.br


I am a second-year PhD student in the Computer Science Department at Duke. I graduated with a Dual Degree (Bachelor + Master of Technology) in Electrical Engineering from the Indian Institute of Technology Madras. I am interested in Algorithms and Complexity, primarily Approximation Algorithms. I am advised by Kamesh Munagala.
Jacob Focke, Dániel Marx, Fionn Mc Inerney, Daniel Neuen, Govind S. Sankar, Philipp Schepper, Philip Wellnitz
Santhini K.A., Govind S. Sankar, Meghana Nasre
Dániel Marx, Govind S. Sankar, Philipp Schepper
Dániel Marx, Govind S. Sankar, Philipp Schepper
Govind S. Sankar, Anand Louis, Meghana Nasre, Prajakta Nimbhorkar


Superconductivity
Contents
Bosons as Fermion Pairs
So far, we have discussed Bose–Einsetein condensation and superfluidity using models of bosonic particles. Can systems of fermions display the same phenomena? Experimentally, we already know that the answer must be yes, as an atom of He$^4$ consists of protons, neutrons, and electrons – two of each – which are are all fermions. A He$^4$ atom is a composite boson, but in many situations its internal structure is of no relevance.
To return to model systems, consider the Fermi gas Hamiltonian that we discussed in the last lecture
For a pair of particles of opposite spin, this is equivalent to
For $U_0<0$ and sufficiently large, we expect a bound state to form with a symmetric spatial wavefunction and a spin singlet. Now consider a dilute gas of such bound pairs. ‘Dilute’ in this context means that the interparticle separation is large compared to the size of the bound state. In this limit, we expect to be able to treat the bound pairs as spinless bosons, which can then display all the usual phenomena associated with Bose gases.
The idea that superfluidity can arise in a system of fermions as a result of pairing was conjectured to explain the phenomenon of superconductivity in metals at low temperatures (Schafroth, 1954). If electrons could form pairs, then superconductivity could be understood as superfluidity of charge $-2e$ bosons. Job done.
You may have spotted the problem with this idea: electrons actually repel each other due to the Coulomb interaction. A realistic description of electron pairing must involve a mechanism for attractive interactions. The 1957 realization of Bardeen, Cooper and Schrieffer (BCS) was that such an attraction is provided by the coupling of the electrons to phonons. For states near the Fermi surface, this attraction can actually overcome the Coulomb repulsion (once screening is accounted for, see Lecture 12). Problem Set 3 describes how this can occur in a simple model.
This is still not the whole story. The net attraction between electrons is still not strong enough to form a bound state, if we were just to consider isolated pair. BCS showed that in a gas of fermions at finite density, arbitrarily weak attraction is enough to cause pairing: it is a truly many body phenomenon. This was first demonstrated by Leon Cooper using a toy model that accounted for the existence of the Fermi sea in the pairing problem, and for this reason we speak of Cooper pairs.
So BCS got the Nobel prize (which conveniently can be split three ways) and their theory become one of the pillars of condensed matter physics. In this lecture we’ll discuss BCS theory using the model Hamiltonian \eqref{super_model} with attractive short-ranged interactions. This is not a particularly realistic model of the combined phonon-mediated attraction and screened Coulomb repulsion, but displays the same physics. It is a good model for pairing of ultracold fermionic atoms, first observed in 2004 (Regal, Greiner, & Jin, 2004).
BCS Theory
The BCS Wavefunction
In momentum space our Hamiltonian \eqref{super_model} has the form
We take the interaction between the two species to be attractive $U_0<0$. The ground state of the non-interacting problem is
The application of the interaction Hamiltonian $H_\text{int}$ generates terms of the form
Note the difference from the Bose case: because the state $\bp=0$ plays no special role – like every other state below the Fermi surface it is occupied with one fermion of each species – we do not just create pair excitations with zero centre of mass momentum $\bq=0$. Nevertheless, the BCS theory starts makes the assumption that the ground state involves a superposition of zero momentum pairs only. We can write such a state very generally as
where the numbers $n_{\bp}^P$ are either $0$ or $1$ (why?). Note that in writing \eqref{pair_fermi} the number of each species is assumed to be exactly $N/2$. Restricting ourselves to states of this form means that
where the first term is the Hartree–Fock energy and $H_{\text{pair}}$ is
Now, can we solve \eqref{super_bcsH}? It’s useful to introduce the operators $\bdop_\bp=\adop_{\bp\uparrow}\adop_{-\bp \downarrow}$ and its conjugate, that create and destroy a $\left(+\bp,-\bp\right)$ pair. Because our pair ansatz \eqref{pair_fermi} only includes amplitudes for a given $\left(+\bp,-\bp\right)$ pair of momenta having either none or two fermions, the pair Hamiltonian can be written in terms of the pair operators $ \bdop_\bp$, $\bop_\bp$ as
This may now look like a quadratic problem, but the pair operators $\bop_\bp$, while commuting at different momenta
obey the hardcore constraint
which is a result of $\bdop$ being composed of a pair of fermions obeying the exclusion principle. Nevertheless, given that a pair that `hops’ into a level at $\bp$ could come from any other level $\bp’$, it seems reasonable to try, as a variational state, one in which the amplitudes for the occupancy of each level are uncorrelated
corresponding to \eqref{pair_fermi} but with a set of coefficients $c_{{n^P_\bp}}$ that factorizes. Finding the variational energy of Equation (\ref{bcs_cons}) is still a tricky problem. For instance, what is the expectation value of the kinetic energy?
Finding the average number of pairs $\langle n^P_\bp\rangle$ in \eqref{bcs_cons} is however not obvious. Instead, we follow the route taken by BCS, and consider instead the normalized wavefunction
This is a superposition of states with different total number of particles. One can see quite easily, however, that the projection onto a fixed number $N$ of particles corresponds exactly to \eqref{bcs_cons} if $c_\bp=v_\bp/u_\bp$. Since \eqref{bcs}) is a product of factors corresponding to each momentum separately, $\langle n^P_\bp\rangle$ is easily found to be $v_\bp^2$. The total variational energy of this state is
What about our use of a non-conserving wavefunction? The expectation value of any operator that itself conserves the number of particles can evidently be written
The probabilities $P_N$ are
which is strongly peaked around $\langle N \rangle=2\sum_\bp |v_\bp|^2=2\sum_\bp \langle n^P_\bp \rangle$, with a variance that is $O(N)$. Thus at large $N$
In the thermodynamic limit, we might as well work with the non-conserving form \eqref{bcs}. To fix the number of particles, we should introduce a chemical potential into the Hamiltonian. Note that we didn’t have to do this with the Bogoliubov theory as we fixed the number of particles in the condensate $N_0$.
There is an interesting alternative interpretation of the pair Hamiltonian \eqref{pair_h}. Acting within the pair subspace, the three operators $\bop_\bp$, $\bdop_\bp$, and $\bdop_\bp\bop_\bp-1/2$ behave as the components of a spin-$1/2$
on account of the commutation relations
This representation is sometimes called Anderson spins. In this way we can write \eqref{pair_h} as a spin chain
where we have included the chemical potential by defining $\xi_\bp\equiv\epsilon(\bp)-\mu$. If we parameterize $\left(u_\bp,v_\bp\right)$ as $(\cos(\theta/2)e^{-i\varphi/2},\sin(\theta/2)e^{i\varphi/2})$ then the variational energy Equation (\ref{bcs_en}) has the form (except for a constant)
The interpretation of \eqref{spin_en} is the following. The first term tends to align the spins with the z-axis in the - direction for $\xi_\bp<0$ and in the + direction for $\xi_\bp>0$. On the other hand, the second term, originating from the potential energy between the constituents of a pair, wants the spins to lie in the x-y plane. Of course, the spins are really quantum mechanical spin-1/2 operators. The direction corresponds to the direction of $\langle \mathbf{S}\rangle$ in the BCS state.
It remains to actually minimize the energy \eqref{bcs_en} to determine the $u$’s and $v$’s, or equivalently, the configurations of the spins. For $U_0>0$ (repulsive interactions), the spins all point in the $\pm z$ direction, forming a ‘domain wall’ where $\xi_{\bp}$ changes sign at the Fermi surface. The relationship between the spin picture and the average number of pairs is
so we see that this corresponds simply to a sharp fermi step. For $U_0<0$, the system can lower its energy by taking $\sin\theta_\bp\neq 0$. The lowering of the interaction energy more than compensates the increase in kinetic energy that comes from smearing the step, see Equation (\ref{ke}). Clearly all of the angles $\varphi_\bp$, describing the angle in the x-y plane, should be equal. Taking the extremum of \eqref{spin_en} with respect to the angles $\theta_{\bp}$ gives the condition
Anderson spin configurations and the associated distribution functions for the free fermi gas (top) and the BCS state (bottom).
where it is convenient to introduce the gap parameter
Thus we have
The meaning of these solutions is very simple. They correspond to the alignment of the spin vector with the direction of the effective `magnetic field’
To be self-consistent, the solution must further satisfy the gap equation
It is clear that for $U_0>0$ there are no non-trivial solutions ($\Delta=0$ always), while for any $U_0<0$ there is always a solution at finite $\Delta$ (One can also show that it corresponds to a minimum of energy. In the repulsive case, the solution at $\Delta=0$, which always exists, corresponds to a maximum). Passing to the continuum limit we have
This integral is divergent in the ultraviolet. We turn to the question of how to regularize it in the next section. More significant, however, is the dependence of the right hand side on $\Delta$ for small $ \Delta$. This is
where $\Lambda$ is the UV cut-off (we will shortly identify it with the Fermi energy), and $\nu(\mu)$ is the density of states per spin component at the chemical potential. This shows that no matter how small the attraction $U_0<0$, there will always be a solution of \eqref{cont_sc} with finite $\Delta$. This is the essence of the Cooper phenomenon. It should be compared with the situation in which there are not a macroscopically large number of particles present. In that case $\mu=0 $, so that $\xi_{\bp}=\epsilon(\bp)>0$. Then the right hand side of \eqref{cont_sc} has no divergence at low energies because the density of states $\nu(E)$ vanishes. The finite value of $\Delta$ is thus seen to be a consequence of the fermi sea.
We have shown that the BCS state, consisting of a superposition of zero momentum pairs, is a better variational state than the Fermi sea for arbitrarily weak attractive interactions. Further, it coincides with the Fermi sea at zero interaction, suggesting a smooth evolution of the ground state as interactions are switched on. What, if anything, does this have to do with the strong coupling picture of tightly bound bosonic pairs in a dilute gas that we gave in the introduction?
Discussion: Heisenberg’s Problem
The BCS-BEC Crossover
Surprisingly, the wavefunctions in the two limits are the same! This can be seen from the first quantized form of the number conserving wavefunction \eqref{bcs_cons}
where $\varphi_\bp=v_\bp/u_\bp$, and $\br^{\uparrow,\downarrow}_j$ are the positions of the spin up and spin down fermions, and we sum over all permutations of $N/2$ objects (assuming $N$ is even).
At weak coupling the extent of the `pair wavefunction’ $\varphi(\br)$ is large compared to the separation between pairs. In this limit the antisymmetrization operation, required by the exclusion principle, plays a dominant role, as we have seen. When the pair wavefunction $\varphi (\br)$ has a much smaller extent than the typical separation between pairs, we can expect that the anitsymmetrization operation in \eqref{bcs_first} is not too important, as two fermions of the same type rarely overlap. In this limit, any given momentum state has a low average occupancy, and the hardcore constraint \eqref{hardcore} does not play a significant role. Then \eqref{pair_h} can really be thought of as a Hamiltonian for isolated pairs, with the corresponding binding energy. The resulting wavefunction is then essentially a Gross-Pitaevskii state of molecules. This all suggests that the BCS state is smoothly connected to the Bose–Einstein condensate (BEC), though the BCS-BEC crossover.
To see how this works in detail we need to address the issue of regularizing \eqref{gap_eq}. The details are given in the Appendix, but the conclusion is very simple. The gap equation can be written in terms of the scattering length $a$ (if you haven’t met scattering theory before, the meaning of this quantity is explained in the Appendix too) of the two-particle potential instead of interaction strength $U_0$
The nice thing about this new equation is that, on account of the second term in the square brackets, the ultraviolet divergence has been eliminated.
In the weak-coupling limit, the gap $\Delta$ is expected to be much smaller than the Fermi energy, and the chemical potential is just equal to the Fermi energy $E_F=k_\text{F}^2/2m$. The integral in \eqref{sc_reg} can then be done explicitly to give the gap
Outside of the weak-coupling limit, we have to account for a change in the chemical potential, in order to keep a fixed density. This is apparent from the equation
The two equations \eqref{sc_reg} and \eqref{mu_eq} are conveniently cast in the dimensionless form
where $\mu$ and $\Delta_0$ are measured in units of $E_F=p_F^2/2m$, and the unit of length is $k_\text{F}^ {-1}$. In these units the total density of particles of both types is $1/3\pi^2$.
Variation of gap and chemical potential accross the BCS (left, weak attraction) to BEC (right, strong attraction).
The point $1/k_\text{F}a=0$, where the scattering length diverges, corresponds to the formation of a bound state. This is an interesting part of the phase diagram, because here (if the temperature is zero) there is only one energy scale (the Fermi energy) and only one length scale (the fermi wavelength). All quantities such as $\Delta$ and $\mu$ are simply some universal fraction of the Fermi energy. In particular the equation of state of the system is
The numerical factors are to emphasize the resemblance of the unitary gas to the free fermi gas, where $ \alpha=1$. The mean field theory above gives $\alpha=0.59$, while a Quantum Monte Carlo calculation found $\alpha=0.44\pm0.01$. There is of course no reason to believe the quantitative predictions of the mean-field theory in the region where interactions are so strong.
Quasiparticle Excitations
Like the Bogoliubov theory, this BCS theory also lets us discuss excitations out of the ground state. We didn’t solve the BCS hamiltonian by a Bogoliubov transformation, as is often done, but we can introduce the Bogoliubov-type excitations after the fact. Recalling the BCS state
it’s easy to see that the operators
satisfy the canonical fermion anticommutation relations and annihilate the BCS state
Consider the state
corresponding to the momentum state $\bp$ certainly containing one particle with (pseudo-)spin $s$, and the $\left(-\bp,-s\right)$ state certainly being empty. The result is an eigenstate of momentum and spin, but is it an energy eigenstate, and thus a sharply defined excitation? Note that if we chose $s= \uparrow$ so that the $\left(\bp,\uparrow\right)$ state is certainly occupied it means that $\adop_{\bp \uparrow}\adop_{-\bp\downarrow}\ket{\bp,\uparrow}=0$, so that the corresponding term no longer appears in the interaction term when it is applied to this state. The level is said to be `blocked’. Thus it certainly is an eigenstate of the pair problem, if $\ket{\text{BCS}}$ is. What is its energy? We have to take into account the kinetic energy as well as the loss of attractive interaction energy, see \eqref{spin_en}
Note that these quasiparticle excitations always have a gap $\Delta_{s}$ given by
As $\mu$ turns from positive to negative as we pass from BCS to BEC (see the above figure), the density of states of the quasiparticle excitations turns from having a square root singularity $\nu(\epsilon)\sim \left(\epsilon-\Delta_s\right)^{-1/2}$ to vanishing like a square root $\nu(\epsilon)\sim \left(\epsilon-\Delta_s\right)^{1/2}$.
Appendix
Regularizing the Gap Equation
The gap equation \eqref{gap_eq} has an ultraviolet divergence – which we also encountered in the Bose gas – that is really a two body effect that arises from our model $\delta$-function potential. To see why this is so, consider the two particle Schrödinger equation
now with a general two-body potential $U(\br_1-\br_2)$. In terms of the relative coordinate $\br=\br_1-\br_2$ this becomes
corresponding to a reduced mass of $\mu = m/2$. In scattering problems we look for solutions of the form
where $\Psi_\text{free}(\br)$ solves the free particle equation, giving the inhomogenous equation for $\Psi_\text{scatt}(\br)$
It is a standard result of scattering theory that the zero energy wavefunction as the form
where $a$ is the (s-wave) scattering length, and $r_0$ is the range of the potential. This corresponds to the behaviour in Fourier space
Returning to the BCS problem, it’s not hard to see that with a general potential the gap parameter is now momentum dependent, leading to a gap equation
The solution of \eqref{gen_gap_eq} is in general very difficult, but it can be greatly simplified if we assume that the range of the potential $U(\br)$ is the shortest length scale in the problem. With this assumption we can write \eqref{gen_gap_eq}
We have added the same term to both sides. However, the integral on the right hand side converges on a scale set by the momentum corresponding to the larger of $\Delta_\bp$ or $\mu$, which by assumption is much less than the scale on which $U_0(\bp)$ varies, and justifies replacing $U_0(\bp- \bp’)$ with $U_0(\bp)$, and $\Delta_{\bp’}$ with $\Delta_0$.
By comparing the Fourier transform of \eqref{inhomog} at $E=0$ and \eqref{super_GapReg}, we can conclude
so that
Which coincides with \eqref{sc_reg} (we drop the subscript $0$ from now on, as we never need to discuss the high momentum behaviour of $\Delta_\bp$ again).
The Effect of Temperature
When we discussed the quasiparticle excitations, we didn’t account for the effect that they have on the self-consistent equation. This is fine when there are few excitations in the system, but when many levels are blocked, we have to take this effect into account, leading to a reduction in the gap parameter. The obvious example of this effect is a system at finite temperature, where the quasiparticles, being fermionic, have the fermi-dirac distribution function
where we allow the quasiparticle energies, and hence distributions, to differ for the two species. Since the occupancy of a given state can be zero or one only $n_s(\bp)$ is also the probability for that state to be occupied. Thus the probability of a $(\bp,s;-\bp,-s)$ state being blocked is $n_s(\bp)\left[1-n_ {-s}(-\bp)\right]+n_{-s}(-\bp)\left[1-n_{s}(\bp)\right]$. What if we have both a $(\bp,s)$ and a $(- \bp,-s)$ quasiparticle present?
which is orthogonal to the BCS state. In the Anderson spin language this corresponds to reversing the direction of spin, as if
with $\theta’ = \pi/2 - \theta$ and $\varphi’ = \varphi + \pi$.
The excitation energy of this state is twice the ‘magnetic field’ each pair experiences $2E(\bp)$, see \eqref{heff}. The spin interpretation allows us to see easily that this state contributes $-u_\bp v_\bp$ to the self consistent equation, and occurs with probability $n_{\uparrow}(\bp)n_{\downarrow}(-\bp)$. The overall result is thus
For the case $E_s(\bp)=E(\bp)$, and in the BCS limit where $\mu\sim E_F$, $\Delta\ll E_F$, this is conveniently presented in the form
where $\nu(E_F)$ is the fermi surface density of states per spin, and we have left out the upper cut-off. This expression needs to be regularized as in the zero temperature case considered before. The resulting $ \Delta(T)$ varies from $\Delta(0)=\Delta_{\text{BCS}}$ given by \eqref{bcs_gap}, to zero at
where $\gamma$ is the Euler–Mascheroni constant. This relationship between $T_\text{c}$ and $\Delta_\text{BCS}$ is a key numerical prediction of the BCS theory. An important point is that the variation is smooth, suggesting a second order transition to a normal (non-superfluid) state above $T_\text{c}$.
There is a small problem. If we continue the calculation through the crossover, the temperature at which a non-zero $\Delta$ develops continues to increase indefinitely on the BEC side (missing reference)
where $E_b=1/ma^2$ is the binding energy of a pair. This temperature should be thought of as a dissociation temperature below which pairs can form (the logarithmic factor is entropic in origin). The temperature at which these pairs condense will however be lower, tending to the ideal bose $T_ {\mathrm{BEC}}$ in the $1/k_\text{F}a\to \infty$ limit. A more sophisticated treatment is required to find a smooth interpolating $T_\text{c}(1/k_\text{F}a)$.
$T_c$ in the mean-field theory (solid line), compared with the result of a treatment that smoothly interpolates to $T_{\text{BEC}}$ (dashed). Reproduced from (missing reference).
References
- Schafroth, M. R. (1954). Theory of superconductivity. Physical Review, 96(5), 1442.
- Regal, C. A., Greiner, M., & Jin, D. S. (2004). Observation of resonance condensation of fermionic atom pairs. Physical Review Letters, 92(4), 040403.


Configuration
interface for obtaining
objects needed to configure applications, such as Exporter
or ProxyPreparer
instances, or other application-specific objects, from configuration
files, databases, or other sources.See: Description
| Interface | Description |
|---|---|
| Configuration |
Defines an interface for obtaining objects needed to configure applications,
such as
Exporter or ProxyPreparer instances, or other
application-specific objects, from configuration files, databases, or other
sources. |
| Class | Description |
|---|---|
| AbstractConfiguration |
A skeletal implementation of the
Configuration interface, used
to simplify writing implementations. |
| AbstractConfiguration.Primitive<T> |
Represents the value of an entry with a primitive type.
|
| ConfigurationFile |
Supplies objects needed to configure applications, such as
Exporter
or ProxyPreparer instances, or application-specific objects,
constructed from data in a configuration source and override options, as
well as data supplied in the call to getEntry . |
| ConfigurationFile.ErrorDescriptor |
Class used to represent a syntax error encountered when parsing a
configuration source or a problem encountered when attempting to return
an existing entry or the type of an existing entry.
|
| ConfigurationProvider |
Provides a standard means for obtaining
Configuration instances,
using a configurable provider. |
| EmptyConfiguration |
A
Configuration with no entries. |
| Exception | Description |
|---|---|
| ConfigurationException |
Thrown if a problem occurs when obtaining configuration information.
|
| ConfigurationNotFoundException |
Thrown if a configuration source location specified when creating a
Configuration is not found, including if null is
specified for provider options and the implementation does not provide
default options. |
| NoSuchEntryException |
Thrown when an attempt to obtain an object from a
Configuration does
not find a matching entry. |
Configuration
interface for obtaining
objects needed to configure applications, such as Exporter
or ProxyPreparer
instances, or other application-specific objects, from configuration
files, databases, or other sources. Application developers are
encouraged to use this interface, rather than explicitly constructing
instances of exporters and proxy preparers, so that applications can be
customized without requiring code modifications. Applications should
normally use ConfigurationProvider
to obtain
Configuration
instances, so that the interpretation of
configuration options can be customized without requiring code
modifications.
The ConfigurationException
class is the
superclass of all exceptions thrown if a problem occurs when obtaining
configuration information. NoSuchEntryException
is the subclass thrown for a missing configuration entry. ConfigurationNotFoundException
is the subclass thrown
for missing configuration source locations and if default options are
requested but not available.
The ConfigurationFile
class is the standard
default configuration provider, which reads text written in a subset of
the expression syntax in the Java(TM) programming language from files
and URLs to produce configuration objects.
The AbstractConfiguration
class is a skeletal
implementation of the Configuration
interface, used to
simplify writing implementations.
The EmptyConfiguration
class implements a
Configuration
with no entries. Applications can use an
instance of this class to simplify handling cases where no configuration
is specified rather than, for example, checking for a null
configuration.
The net.jini.config.GroovyConfig class is a new configuration provider, it uses Groovy configuration objects, this is potentially the most powerful configuration mechanism.
Using Configuration
Once an application gets a Configuration
using
ConfigurationProvider
or through an application-specific
mechanism, the application should pass that configuration to other
subsystems that need configuration information, in addition to using it
for its own needs. This arrangement provides the user with a uniform way
to supply configuration information to all the components that make up
an application.
The names that applications and subsystems use for configuration entries
should be chosen carefully to avoid conflicts. One possible approach is
to use fully qualified class names as the component for configurable
applications and utilities, and to use fully qualified package names as
the component for services. For each entry, the decision should be made
whether to supply a default or to throw
NoSuchEntryException
if there is no matching
entry. Components should document which configuration entries they use,
as well as the expected type and default, if any, for each entry.
Example
Here is a sketch of how to use these facilities for an application with
configurable exporting. The class below shows exporting an object using
a Configuration
:
import java.rmi.*; import net.jini.config.*; import net.jini.export.*; public class Example implements Remote { public static void main(String[] args) throws Exception { Configuration config = ConfigurationProvider.getInstance(args); Exporter exporter = (Exporter) config.getEntry( "Example", "exporter", Exporter.class); Remote proxy = exporter.export(new Example()); System.out.println(proxy); exporter.unexport(true); } }
Here are the contents of a ConfigurationFile
source file to
export the object using an JRMP exporter:
import net.jini.jrmp.*; Example { exporter = new JrmpExporter(); }
Here are the contents of another ConfigurationFile
to
export the object using a Jini extensible remote invocation (Jini
ERI) exporter over HTTP on a specific port:
import net.jini.jeri.*; import net.jini.jeri.http.*; Example { exporter = new BasicJeriExporter(HttpServerEndpoint.getInstance(12000)); }
This application can be configured to export the object in either of these ways (or more with other configuration files) by passing an argument that specifies the location of one of the configuration files:
java Example jrmp.config java Example jeri.config


Rajnath Singh to attend the ADMM-Plus meeting in Bangkok today
In addition to the 10 ASEAN countries, eight countries such as Japan, the U.S. and China participate at this meeting to promote more practical defence cooperation
by PTIDefence Minister Rajnath Singh arrived in Bangkok on Saturday to attend the ADMM-Plus meeting where Defence Ninisters of ASEAN countries and eight other nations would gather and discuss the way forward for security cooperation.
“Rajnath Singh arrived in Bangkok today to attend ASEAN Defence Ministers’ Meeting-Plus (ADMM-Plus) and the opening ceremony of Defence and Security 2019 Exhibition,” a government press release said.
Mr. Singh is scheduled to attend the ADMM-Plus meeting in Bangkok, Thailand, on Sunday.
As part of the agenda for the ADMM-Plus meeting, Singh will also release a “Handbook on Military Medicine for ASEAN (Association of Southeast Asian Nations)” along with Myanmar Defence Minister Lieutenant General Sein Win.
“Bilateral meetings with several participating defence ministers are planned,” the release said.
In addition to the 10 ASEAN countries, eight countries such as Japan, the U.S. and China participate at this meeting to promote more practical defence cooperation.
During his two-day visit, Mr. Singh will also inaugurate the India pavilion at the Defence and Security Exhibition in Bangkok.
“He will address the business seminar and interact with the industry representatives,” the release said.
A courtesy call on Thailand Prime Minister Prayut Chan-o-cha will also take place during the visit, it said.


Rewrite the following in the form log(c).
\log(A) + \log(B)
C
Use the rule: \log(a) + \log(b) = \log(a \cdot b)
.
\log(A) + \log(B) = \log(A \cdot B)
= \log(C)
Rewrite in the form log(c).
\log(C) - \log(A)
B
Use the rule: \log(a) - \log(b) = \log(\frac{a}{b})
.
\log(C) - \log(A) = \log(\frac{C}{A})
= \log( B )
Rewrite in the form log(c).
A\log(B)
pow( B, A )
Use the rule: n \cdot \log(a) = \log(a^{n})
.
A\log(B) = \log(B^{A})
= \log(pow( B, A ))


Resturant Menu
Major Dishes:
Vegitable Pulav
Hydrabadi
Roti with Veggies
Starters:
Gobhi Manchurian
Veg Clear Soup
Masala Papad
Soft Drinks:
Pepsi
Coke
Lime Soda


| Path: | README |
| Last Update: | Mon Jul 27 15:13:09 -0500 2009 |
Roadmap available at redmine.kineticdata.com/projects/roadmap/ars-ng-arsmodels
The Ars Models Ruby package is a JRuby wrapper implementations of the Kinetic Ars Models Java source classes, which simplify Ars interactions by exposing abstracted CRUD methods for common Ars objects. The Ruby models wrap Java calls to implement common Ruby paradigms, such as a method accepting a hash of options, and to convert the results from Java to Ruby datatypes.
The Ars Models Ruby package is deployed using SVN.
To checkout the full project, run the following command:
$ svn co https://svn9.cvsdude.com/KineticData/arsModels/trunk
To checkout and install the project gem, run the following commands:
$ svn co https://svn9.cvsdude.com/KineticData/arsModels/trunk/pkg $ gem uninstall ars-models # Do this only if ars-models is already installed $ gem install pkg/ars-models-$VERSION$.gem
If Ars Models was installed as a full source package, the library can be loaded by calling ‘load’ or ‘require’ on "%PACKAGE_ROOT%/init" or "%PACKAGE_ROOT%/lib/ars_models". For example:
require File.expand_path(File.join(File.dirname(__FILE__), '..', 'ArsModels', 'lib', 'ars_models'))
If Ars Models was installed as a gem, the library can be loaded by calling ‘load’ or ‘require’ on "ars_models". For example:
require 'ars_models'
# TODO: Getting Started
# TODO: Examples
# TODO: Field Type documentation
For more information and sample usage, see the rdoc included with the package.
Note: If you installed Ars Models via the gem, the rdoc can be accessed by starting a gem server. To browse the gemmed rdoc, start a local gem server using the command below and open a browser to <IP_ADDRESS>:8080.
$ jruby -S gem server -p 8080


If you have any questions about our service, please contact us using the following ways;
phone +1(800) 555-JOSH
email<EMAIL_ADDRESS>share Facebook, Twitter, or Instagram: @joshandjames3dprints
WE HAVE A CONSTANT STAFF OF PROFESSIONAL 3D PRINTERS WAITING BY PHONE AND COMPUTERS (7am-12pm) TO ANSWER YOUR QUESTIONS AND TO AID YOU THROUGH HELP ABOUT OUR SERVICE.
From Shutterstock, linked to our customer support chat


ESC
to pause
Characters
Rainbow
Grayscale
Red
Green
Blue
Pastel
Dark
gyroscope jump gyroscope jump fun game
Score: 0
High Score: 0
Reset
WASD/ arrow keys; avoid being submerged in the red rising from the bottom (go ↑↑). AVOID the falling books
appear on the other side→
GAME OVER
RETRY


Demo chat (Vertx.io) application demonstrate how to handle persistent queue messages with sensitive user data (like support chat)
Chat records that persist into a queue (kafka) are very hard to clean is a user wish to be forgotten.
This demo app persist the chat messages to a queue with encryption, this way we can delete the user private key making all user chat messages inaccessible
Welcome to our grocery store!


v. 0.1.2
| Number of connections: | Average length of connections: | Ticks in 1sec if average connection is 110ms: | |||
| Ticks: | Active connection attempts: | ||||
Contents
There are at least two significant limitations to be aware of when using this simulation:
These are just the width and height of the html canvas object. Nodes are distributed evenly throughout the canvas. So size does matter. If you have lots of nodes, it needs to be bigger otherwise it's hard to see what's happening. If you have few nodes, a large canvas, and a small distance for nodes to connect, then the network won't join up properly.
Estimates of the number of nodes (with rough numbers as at 22 August 2020):
"Bad Nodes" are nodes that are complicit with the double spend attack. They are programmed to refuse the original transaction, so will only process the double spend transaction. As noted in the section on limitations, the simulation over emphasises the effects of bad nodes on a large network, because it generously assumes that the attacker is able to control nodes that are well distributed and connected throughtout the network. In reality, for a large network, this is extremely difficult—maybe impossible—to achieve.
In Bitcoin Core default settings, maximum available connection slots per node are 117, this figure comes from: https://en.bitcoin.it/wiki/Clearing_Up_Misconceptions_About_Full_Nodes#Very_roughly_estimating_the_total_node_count
People running nodes with poorer internet connection and weaker hardware may restrict the number of connections they make, but I presume they would want a certain number of connections to justify having a node at all. I arbitrarily picked 20 as the default for this figure.
Technically speaking, for every block, there is only one mining node.
This is really, really, really important to understand, and a lot of people don't recognise the implications: for every block, there is only one mining node. This is because mining is a zero-sum game.
That means that—for every single block—there are numNodes-1 non-mining nodes.
This simulator only simulates a time span leading up the winning of one block. If you wait until the end of the simulation, it will randomly choose a winning node to generate the next block. This node is the only true "mining node" for that block.
So, what does "number of mining nodes" mean? It means the number of nodes that are racing to find the hash for the next block. The only relevance that the number of and computing power possessed by these nodes have to the blockchain is that they influence the difficulty of the following block. But, the difficulty of the next block is completely irrelevant to the process of transaction propagation. When transactions are propagating before a block is mined, any node that doesn't win the block will end up being non-mining nodes for that block. Furthermore, the endtire network is "blind" as to which node will actually win the block. Two competing versions of a transaction are therefore like a selfish gene: propagating as far as possible, until ultimately one node—and nobody knows which one—will win a block. Whichever transaction that node has received when it wins the block will be written to the chain.
Not only does a transaction not know which node will "win", it also doesn't know which nodes are even trying to find a block this time around.
The screen distance between nodes in the simulation represents latency in the connection between nodes. For this discussion, I will assume that the average latency between peers is 110ms (see https://hackingdistributed.com/2017/02/15/state-of-the-bitcoin-network/#:~:text=The%20figure%20shows%20the%20estimated,peers%20is%20around%20110%20ms.).
Currently, this distance is measured in number of pixels divided by 2 (in the JS this number is stored in the variable distanceDivider). This number was chosen just so the simulation progresses at a pleasing speed. We can call these "distance units".
After creating the nodes, as of v. 0.1.1 the simulator will display how many connections there are and their average length in distance units. From this, you can decide how long to set the "Double Spend Delay" parameter. In Satoshi's Snack Machine Problem post, he/she/they imagined a double spend attack as having a delay of about 1 sec. In almost all scenarios the entire network is saturated by then, so test the strength of a network a shorter timeframe needs to be selected. To help estimate how many ticks to leave, as of v. 0.1.2 the simulation gives you an estimate of how many ticks there are in a second assuming that average time between peers is 110ms.
Limiting the distance between peers can simulate a "mesh" network with less interconnecivity.
The number of ticks before the double spend attack begins. Use the estimated "ticks per second" to get a sense of how much time a tick represents.
The background to this simulation is Satoshi's post on "The Snack Machine Problem", available here: https://bitcointalk.org/index.php?topic=423.msg3819#msg3819
Satoshi was responding to a thread where someone had posed this problem (here quoted in full, but emphasis mine and I have labelled two sentences A and B):
How would a Bitcoin snack machine work?
1) You want to walk up to the machine. Send it a bitcoin.
2) ?
3) Walk away eating your nice sugary snack. (Profit!)
You don't want to have to wait an hour for you transaction to be confirmed. (A)
The vending machine company doesn't want to give away lots of free candy. (B)
How does step 2 work?
The (false) assumption behind this problem is that Bitcoin transactions are validated by miners. This assumption is evident from sentences A and B.
If one makes this assumption, then on the surface a Bitcoin snack machine would seem to be impossible, because:
If miners validate transactions, then the snack machine doesn't seem possible, hence the original post.
There was a lot of discussion in response to this post, but I will just skip ahead to Satoshi's answer to this problem. Here's the whole of Satoshi's response (again, all emphasis mine, and I've labelled some sentences):
I believe it'll be possible for a payment processing company to provide as a service the rapid distribution of transactions with good-enough checking in something like 10 seconds or less. (A)
The network nodes only accept the first version of a transaction they receive to incorporate into the block they're trying to generate (B). When you broadcast a transaction, if someone else broadcasts a double-spend at the same time, it's a race to propagate to the most nodes first (C). If one has a slight head start, it'll geometrically spread through the network faster and get most of the nodes (D).
A rough back-of-the-envelope example: (E)
1 0
4 1
16 4
64 16
80% 20%
So if a double-spend has to wait even a second, it has a huge disadvantage.
The payment processor has connections with many nodes (F). When it gets a transaction, it blasts it out, and at the same time monitors the network for double-spends (G). If it receives a double-spend on any of its many listening nodes, then it alerts that the transaction is bad (H). A double-spent transaction wouldn't get very far without one of the listeners hearing it (I). The double-spender would have to wait until the listening phase is over, but by then, the payment processor's broadcast has reached most nodes, or is so far ahead in propagating that the double-spender has no hope of grabbing a significant percentage of the remaining nodes.
It was this post and this explanation about which Satoshi said his famous "If you don't believe me or don't get it, I don't have time to try to convince you, sorry." You can see that here: https://bitcointalk.org/index.php?topic=532.msg6306#msg6306
And it is certainly the case that after the block size wars, the point Satoshi made in this post is one of the most misunderstood things about Bitcoin. So, let's examine what he says very carefully:
Sentence A shows Satoshi is imagining a situation where transactions are validated before they are written to the blockchain:
So, Satoshi thought that something other than the blockchain would validate the transaction. This validation is: (a) faster than finding a block; (b) less secure than finding a block, but "good enough".
Sentence B shows that Satoshi thought nodes would perform this checking before a block is created:
So, Satoshi thought that before writing a block to the blockchain nodes would undergo a process of validating transactions by accepting only the first version of transactions they receive, and rejecting different versions they receive after this.
Satoshi's post imagines that there are at least two races going on within the Bitcoin network. The most famous race is clearly described in the Whitepaper: it is the race for nodes to find the next block.
But! Sentence C describes the pre-blockchain validation process as "a race to propagate to the most nodes first". This is a different race to the hash-war to find the next block.
This race is what the above script simulates: the race between a transaction and a double spend to propagate throughout the network of nodes.
Twelve days after his/her/their response to the Bitcoin Snack Machine thread, Satoshi referred back to the comment in response to another post about scaling. In this later post, Satoshi describes what he/she/they imagine the future of the Bitcoin network to look like. Satoshi's comments in that post are frequently cited on the internet out of context, and misread. So, here is the full text of the original post to which Satoshi was responding (as before, emphasis and sentence labelling mine):
I'm curious about the developers feelings on scalability. For example, could the system handle a million users, doing say 5 transactions each per day. 5 million transactions per day is roughly 35,000 transactions per 10 minute period?
Is there a bottle neck in propagating 35,000 transactions to a million nodes for block generation (A)? Or has that issue been designed for?
Post 2016, the Bitcoin scaling debate has been almost exclusively about how many transactions fit into a block. But the question being asked by this poster in 2010 was whether there would be a scaling bottleneck in the propagation of transactions.
There was a lot of discussion in response to that post also, but instead of jumping straight to Satoshi's response, I will stop at an earlier post in the thread. This is an important post, because Satoshi quotes it and directly responds to it later. It is available here: https://bitcointalk.org/index.php?topic=532.msg6269#msg6269 (emphasis and sentence labelling again mine):
I am convinced that bandwidth, disk space, and computation time necessary to distribute and "finalize" a transaction will be prohibitively expensive for micro-payments (A). Consider for a second that the current banking industry is unable to provide a reasonable micropayment solution that does not involve depositing a reasonable sum and only allowing a withdraw after a reasonable sum has been accumulated.
Besides, 10 minutes is too long to verify that payment is good. It needs to be as fast as swiping a credit card is today.
Thus we need bit-banks that allow instant transfers among members and peer banks (B). Anyone can open a bit-bank but the system would, by necessity operate on some level of trust. Transfers in and out of the banks and peer-to-peer would still be possible but will be more costly. Thus, a bit bank could make money by enabling transfers cheaper and faster than the swarm with the added risk of trusting the bank. A bank has to maintain trust to make money.
In this final response on the thread before Satoshi posts, the user is talking about two problems with transactions. These are described in sentence A: 1. distributing transactions and 2. finalising transactions. It is important to recognise that discussion of these two different things are the context of Satoshi's response.
Note also in sentence B that the user had suggested there would be a need for "bit-banks", i.e. some sort of trusted 3rd party. In the first paragraph of the Whitepaper Satoshi articulates the problem that Bitcoin solves as being a need for a financial system without trusted 3rd parties. It is therefore not a surprise that at this point in the thread, Satoshi responds.
Here is now the whole of Satoshi's response, which is available here: https://bitcointalk.org/index.php?topic=532.msg6306#msg6306 (again, all emphasis mine, and I've labelled some sentences):
The current system where every user is a network node is not the intended configuration for large scale (A). That would be like every Usenet user runs their own NNTP server (B). The design supports letting users just be users (C). The more burden it is to run a node, the fewer nodes there will be (D). Those few nodes will be big server farms (E). The rest will be client nodes that only do transactions and don't generate (F).
Quote from: bytemaster on July 28, 2010, 08:59:42 PM
Besides, 10 minutes is too long to verify that payment is good. It needs to be as fast as swiping a credit card is today.
See the snack machine thread, I outline how a payment processor could verify payments well enough (G), actually really well (much lower fraud rate than credit cards), in something like 10 seconds or less. If you don't believe me or don't get it, I don't have time to try to convince you, sorry.
http://bitcointalk.org/index.php?topic=423.msg3819#msg3819
The context to this post was an original question about whether transaction propagation could scale, and the immediately preceding post doubted whether transactions could not be economically 1. distributed and 2. finalised for micropayments. In Satoshi's first paragraph he/she/they address these two issues separately:
In Sentence A Satoshi describes that when the Bitcoin system grows to a "large scale" it will have to change. Here Satoshi uses the term "network node". This term is contrasted with another term at the end of the paragraph: "client nodes" in sentence F. What are these two different types of nodes? What do they do? Our aim here will be to answer these questions, but first because this paragraph is frequently misunderstood, we must look carefully at the function of sentence D in the paragraph, and what Satoshi is attempting to achieve by writing the paragraph.
In sentence D Satoshi simply uses the term "node". A frequent misunderstanding of Satoshi's post here is to equate "node" with the previous reference to "network node". This misunderstanding reads sentence D as essentially repeating what was said in sentence A. But, rather, sentence D builds on the previous argument by making a general observation about what happens in systems where running nodes becomes burdensome. Two pieces of evidence for this interpretation are that (a) people tend not to repeat themselves needlessly, and especially not Satoshi who's words seems always efficient, and (b) the two sentences following this generalised observation demonstrate a category split between two different types of nodes in his/her/their mind(s): the "few nodes" that will be "server farms" (sentence E) and the "rest" of the nodes that will be "client nodes" (sentence F).
What is the purpose of Satoshi's paragraph? What is Satoshi trying to achieve? (In literary studies this is called discovering the "pragmatic effect" of a discourse). The paragraph is introducing his/her/their readers to the idea of two different kinds of node. This is a new idea for the people Satoshi is speaking to, because for the readers contemporary with Satoshi all nodes were the same (as Satoshi stated in sentence A), this is why Satoshi had to explain idea of two different types of nodes. It is also, therefore, not a surprise to consider that this distinction in types of nodes was not described in the Bitcoin Whitepaper. This paragraph therefore also provides evidence that Satoshi did not expect Bitcoin to remain identical to the system he/she/they described in the Whitepaper.
So, having examined some of the details of the paragraph, let us now try to understand what these different types of nodes are by listing their properties in a table:
| network node (A) | client node (F) | |
|---|---|---|
| illustration: | Usenet NNTP server (B) | Usenet user (B) |
| number of nodes: | few (D) | many (implied by D and F) |
| scale: | big server farms (E) | user (C) |
| function: | do transactions and generate (implied by F) | only do transactions and don't generate (F) |
What does Satoshi mean to "do transactions" and to "generate"? Remember the context: The start of the thread was about whether the propagation of transcations would scale. The previous poster had talked about "distributing" transactions and "finalising" transactions. Furthermore, consider sentence G where Satoshi references back to the Snack Machine post where he says he argued that "a payment processor could verify payments well enough".
Therefore:
A "client node" that can "do transactions" would seem to be a node that propagates transactions through the network. The "payment processor" is a "user".
A "network node" that can "do transactions" but also "generate" would seem to be a node that can generate blocks.
In the context that Satoshi was writing, it was normal and expected that all users of Bitcoin were running nodes that validate transactions and generate blocks. Satoshi envisages a time when only a small number of "network nodes" generate blocks, but he/she/they still imagine all users running nodes.
Karame, Ghassan O., Elli Androulaki, and Srdjan Capkun. "Two Bitcoins at the Price of One? Double-Spending Attacks on Fast Payments in Bitcoin."
| 0.1.2 | Displays average ticks per sec. |
| 0.1.1 | Displays connection number and average length. |
| 0.1 | First version |


We're a friendly bunch of devs who meet weekly, to discuss everything and anything related to development, web and otherwise - frontend, backend, convoluted database/XML/JSON issues, OO design, TDD, Linux ops, you name it. PHP, Laravel, Ruby, JQuery, CSS, SASS, MongoDB, Redis, Java, C#, Golang and more.

Anyone and everyone welcome!
as long as they can chip in for pizza
Baxter Building,
80 Baxter Ave
Every Tuesday
6pm - 9/10pm
Gary! or Jeff?
Talk the geek talk...
...sometimes. More pizza than code.


- label - Variable in class sets.general.FuzzySet
-
Name that the user gives to the set.
- LabelExists - Class in primitives.labeling
-
This class implements the primitive label-exists?.
- LabelExists() - Constructor for class primitives.labeling.LabelExists
-
- LabelOfSet - Class in primitives.labeling
-
This class implements the primitive label-of.
- LabelOfSet() - Constructor for class primitives.labeling.LabelOfSet
-
- LGEFormat(LogoList, int) - Static method in class general.SupportFunctions
-
Checks the format of Logistic,Exponential and Gaussian sets
- load(PrimitiveManager) - Method in class general.FuzzyLogic
-
- Logistic - Class in primitives.creation
-
This class creates a new logistic set.
- Logistic() - Constructor for class primitives.creation.Logistic
-
- LogisticSet - Class in sets.function
-
This class represents logistic sets.
- LogisticSet(List<Double>, boolean, String, double[]) - Constructor for class sets.function.LogisticSet
-
Call the constructor of FunctionSet.
- LogisticWithLabel - Class in primitives.creation
-
This class creates a new logistic set with the label given.
- LogisticWithLabel() - Constructor for class primitives.creation.LogisticWithLabel
-
- LOM - Class in primitives.defuzzification
-
This class implements the lom-of primitive.Last of Maxima.
- LOM() - Constructor for class primitives.defuzzification.LOM
-
- lowerEnvelope(PointSet, PointSet) - Static method in class general.DegreeOfFulfillment
-
Calculate the lower envelope of two piecewise linear sets.
- LowerEnvelope - Class in general
-
This class implements the lower-envelope primitive.
- LowerEnvelope() - Constructor for class general.LowerEnvelope
-


Do you suspect that a child is in distress ?
Help him/her by just uploading the information for others to know and help.
Click here to upload
Do you know if a child is gone missing ?
Just post an AD and help the child to return to where he/she belongs.
Click here to upload


Get information about your computer's operating system.
Get information about your computer's network interfaces and their connection status.
Get information about your computer's battery.


Content to log.
Logging options, see LogOptions
.
Logs something using .toString()
.
Content to log.
Logging options, see LogOptions
.
Logs something with cyan tag "DEBUG" if LogContext.debug
is set.
Content to log.
Logging options, see LogOptions
.
Logs something with red tag "ERROR" if LogContext.error
is set.
Content to log.
Logging options, see LogOptions
.
Logs something with blue tag "INFO" if LogContext.info
is set.
Content to log.
Logging options, see LogOptions
.
Logs something as a string with blue tag "$" if LogContext.internal
is set. Used as logging inside the library.
Content to log.
Logging options, see LogOptions
.
Logs something with no newline at the end.
Content to log.
Logging options, see LogOptions
.
Logs something as a string with magenta tag "*" if LogContext.star
is set.
Content to log.
Logging options, see LogOptions
.
Logs something to stderr.
Content to log.
Logging options, see LogOptions
.
Logs something with green tag "SUCCESS" if LogContext.success
is set.
Content to log.
Logging options, see LogOptions
.
Logs something with yellow tag "WARN" if LogContext.warn
is set.
Content to log.
Logging options, see LogOptions
.
The context for the logging functions.
Generated using TypeDoc
Logs something.


Most days biking: "Is my tire flat? Nope just weak legs." Today in the rain: "Sure is tough riding today." Flat. 🚲💨😫
2/18/2014, 9:19:12 AM
Favs: 0
Retweets: 0
link--- layout: tweet ---
Most days biking: "Is my tire flat? Nope just weak legs." Today in the rain: "Sure is tough riding today." Flat. 🚲💨😫
2/18/2014, 9:19:12 AM
Favs: 0
Retweets: 0
link


We could not deliver a Signal notification to {{ recipient|mask_phone }} due to
hitting a rate-limit on the Signal network, so we are sending it via email
instead:
{{ message|safe|linebreaksbr }}
{% endblock %}
{% block content_more %}
Regards,
The {% site_name %} Team
{% endblock %}


Simple utility to convert function type declarations from MSDN or other sites to a format compatible with IDA Pro.
If you like this, consider supporting me on GitHub Sponsors. Pull requests here.
NTSYSAPI NTSTATUS ZwMapViewOfSection( [in] HANDLE SectionHandle, [in] HANDLE ProcessHandle, [in, out] PVOID *BaseAddress, [in] ULONG_PTR ZeroBits, [in] SIZE_T CommitSize, [in, out, optional] PLARGE_INTEGER SectionOffset, [in, out] PSIZE_T ViewSize, [in] SECTION_INHERIT InheritDisposition, [in] ULONG AllocationType, [in] ULONG Win32Protect );
Convert & Copy


Well it is warm here at Miami Beach; we thought by now we
would be headed to the Bahamas, but the weather is just
not behaving. When you leave from Miami area you have to
cross the Gulf Stream to get to the Bahamas. That water in
the Gulf Stream is moving south to north at about 5 knots.
When the winds are out of the north going against the Gulf
Stream the waves start to build and have been in the 6 to 10
foot seas. This is something we really wanted to avoid so
we have been waiting for the winds to clock around to the
southerly direction. When that happens the waves go down
into the 0 to 2 foot seas, much nicer. So we sit and wait,
could be worse places to wait.
We have anchored off the main shipping channel into Miami over
on the Miami Beach side. This allows use to watch the
cruise ships come in and out of the port. There are a lot
of cruise ships Every day it seems there are two to three new
ones at the dock, and most are rather large. We have spent
some time walking up and down the South Beach area.
South Beach has a lot of personality and diversity. There
are distinct cultural groups here, with a large Latin influence.
It is rather fun to just people watch. We ate lunch
at a Cuban restaurant the other day for Kris's birthday.
It seems like you can find all types of food and stores
depending upon what you are looking for. There are several
large grocery stores here, so we have finished all our
provisioning, and are ready to go when the weather turns.
There are several boats in this anchorage and we have heard
there are a lot more just south of us waiting for the same
weather window to head east. So far the first real good
opportunity looks to be on Monday/Tuesday, the 10th or 11th.
We have all been doing good health wise, Derek lost another
tooth the other day, it came out after he ate some gooey candy.
We think only a couple more teeth to go. We will
have to take him to a dentist sooner or later, but he is voting
for the much much later option.
We have met some new folks here, also cruisers waiting to head
over to the Bahamas as well, but none with kids. We
haven't seen many cruising kids this year, but hope that we can
meet up with more once in Georgetown Bahamas.
Update 12/07/12; Miami Beach


|
Finite Geometry Notes
|
The typical example of a finite group is GL(n,q), the general linear group of n dimensions over the field with q elements. The student who is introduced to the subject with other examples is being completely misled. -- J. L. Alperin [AL]Among the algebraic structures known as fields, clearly the most important for applications are the rationals, the reals, and the complex numbers, together with the fields of rational functions with coefficients in one of these number fields. What is the next most important field? Combinatorialists, coding theorists, and computer scientists would be likely to name the ridiculously simple structure F2, consisting of the elements 0 and 1, with 1 + 1 = 0.
One reason for the importance of this field is that the 1's in a vector in an n-space over F2 can be used to indicate membership in a subset of an n-set, with addition of vectors corresponding to taking the symmetric difference of sets. A family of subsets corresponds to a set of vectors, which in turn generate a vector subspace that may be easier to work with than the original subsets. Permutations on the parent n-set that leave the family of subsets invariant induce linear transformations on the corresponding subspaces. (J. H. Conway's analysis of M24, sketched below, exemplifies this approach to working with subsets.)
These considerations, and Alperin's remarks quoted above, indicate that linear and affine maps on vector spaces over F2 are reasonable things to study. Just as in linear algebra over the reals, the student working over F2 may be helped by seeing low-dimensional examples of how linear and affine maps actually move points throughout a vector space. (Over the reals, the student can visualize the global effects of such things as shears, dilations, rotations, and reflections.) We will describe how one can at least begin to visualize global actions of the linear and affine groups of 2, 3, 4, and 6 dimensions over F2, by constructing generators for these groups that have easily pictured actions on square and cubical arrays of points. (The awkward case of 5 dimensions we leave as an exercise.)
Before delving into the construction of these low-dimensional groups, we first show that their sizes are nontrivial, and then note that one of them, GL(4,2), has several nice properties that make it of particular interest to group theorists.
The notation GL(n,q) gives little idea of the size of these groups, which grow quite rapidly as n increases. As an aid to intuition, we list the orders of the first six general linear groups over F2, and of the corresponding affine groups AGL(n,2). Here AGL(n,2) is a semidirect product of the elementary abelian group V(n,2) of order 2n (the translation group) by GL(n,2). (In fact, AGL(n,q) is the holomorph of V(n,q). See [RO, pp. 136-139] and [CA, pp. 68, 112-113].)
| Group | Order of group |
|---|---|
| GL(1, 2) | 1 |
| AGL(1, 2) | 2 |
| GL(2, 2) (=S3) | 6 |
| AGL(2, 2) (=S4) | 24 |
| GL(3, 2) | 168 |
| AGL(3, 2) | 1,344 |
| GL(4, 2) | 20,160 |
| AGL(4, 2) | 322,560 |
| GL(5, 2) | 9,999,360 |
| AGL(5, 2) | 319,979,520 |
| GL(6, 2) | 20,158,709,760 |
| AGL(6, 2) | 1,290,157,424,640 |
To verify these numbers, note that the order of GL(n,q) is
(qn - 1)(qn - q)(qn - q2)...(qn
- qn-1),
which is the number of ways to choose successive images of basis
vectors, and that
|AGL(n,q)| = qn|GL(n,q)|.
Among the groups above, GL(4,2) has several nice properties that make it of particular interest to students of group theory, combinatorics, or finite geometry.
We now describe how to generate eight of the groups on our list above, of orders 6 through approximately 1.3 trillion, by letting the symmetric groups S3 (for linear groups) or S4 (for affine groups) permute natural subdivisions of square or cubical arrays.
We first recall that a permutation group acting on spatially located objects has isomorphic "alias" and "alibi" interpretations, depending on whether the cycle (ab...) means that object a is replaced by object b, etc. ("alias"), or whether it means that the object in location a is replaced by the object in location b, etc. ("alibi"). To avoid confusion we will use the alibi approach throughout, and will apply labels (numbers or (0,1)-vectors) only to locations within square or cubical arrays, and not to the objects permuted, which are "points" represented by unlabeled square or cubical unit cells. (The reader may, of course, label these cells as he pleases.)
Our groups will act on the following arrays of unit cells: a 2x2 square, a 2x2x2 cube, a 4x4 square, and a 4x4x4 cube. In each case, the same mathod of labeling locations is used:
By a standard result of linear algebra [AR, ch. IV] the group of all unimodular linear transformations on an n-space over a field, i.e. the group of all nxn matrices with determinant 1, is generated by transvections, i.e. by the matrices Bij(t) obtained from the identity matrix by substituting the scalar t for one of the 0's. Since we are working over F2, every nonsingular linear transformation is unimodular, so the transvections Bij are the only generators for GL(n, 2) we need examine.
A quick check shows that for the 2x2 array as labeled above, the Bij for GL(2, 2) generate the action of S3 on the three unit cells not located at the origin (0, 0).
Given this S3action, clearly AGL(2, 2) acts as S4, since any nonzero translation moves the cell at the origin into the S3 orbit.
For the 2x2x2 array, the transvections of GL(3, 2) are easily seen to generate copies of the S3 action on the top, left, and back of the cube, with this action being extended through adjacent layers. In other words, GL(3, 2) is generated by S3 acting in each of 3 sets of 4 parallel 1x1x2 sections of the cube, with the fourth section in each set being fixed under S3's action on that set, since the fourth section contains the cell located at the origin. By the same argument as above, AGL(3, 2) is generated by S4 acting on each of the 3 sets of 4 parallel 1x1x2 sections.
For the 4x4 array, 6 of the Bij generate all 12 transvections, and also generate the action of S3 on the 3 rows, the 3 columns, and the 3 2x2 quadrants of cells that do not contain the cell located at the origin. Again, it is clear that AGL(4, 2) is generated by the action of S4 on rows, on columns, and on quadrants.
For GL(6, 2) acting on the 4x4x4 cube, consider the three 4x4 submatrices of the 6x6 identity matrix that correspond to the 3 sets of parallel 1x4x4 layers of the cube such that 4 of the 6 coordinates are identical throughout the four layers in a set. Together, these three submatrices cover all possible locations for a 1 located outside the diagonal in a 6x6 transvection matrix. It follows that the actions of GL(6 2) on the 4x4x4 cube are generated by S3 permuting any 3 parallel 1x4x4 layers not containing a cell at the origin and by S3 permuting any 3 parallel 2x2x4 sections not containing a cell at the origin. Naturally, AGL(6, 2) is generated by arbitrary permutations of parallel layers and of parallel 2x2x4 sections.
We conclude by mentioning an application to symmetries of ornamental patterns. Consider a cubic cell that is colored white around each of two opposite corners, in an area bounded by diagonals of the faces surrounding these corners, and black elsewhere, so that a band of black running around the cube separates the two white "caps," which are images of one another under a reflection in the center of the cube. If the reader arranges such cubes into a diamond pattern within any of the arrays we have discussed, he is likely to find that the resulting pattern has either an ordinary or a color-interchange symmetry under some rigid motion (rotation, reflection, or inversion) of the entire array. That such symmetry always occurs, given the right sort of starting pattern, is due to the Euclidean symmetries of partitions by affine hyperplanes.
For a summary of these results, see Affine groups on small binary spaces.
For a look at AGL(4, 2) in action, see The Diamond 16 Puzzle.


FreeRADIUS is developed under the GNU General Public License, Version 2 (GPLv2), and is free for download and use.
Public Releases
The latest version of the server is .tar.gz"> version .tar.gz.sig">(PGP Signature) We strongly recommend that you use it in preference to an older version. The older versions are available for archival reasons, and should not be used. The following PGP key may be used to validate the release binaries.
We do not make binary packages available, but they are referenced from the OS page.
- 1.1.0 (2006.01.12), 1.1.1 (2006.03.20), 1.1.2 (2006.05.26), 1.1.3 (2006.08.22), 1.1.4 (2007.01.04), 1.1.5 (2007.03.05), 1.1.6 (2007.04.12), 1.1.7 (2007.07.25).
- 1.0.0 (2004.08.09), 1.0.1 (2004.08.17), 1.0.2 (2005.02.16), 1.0.3 (2005.06.03), 1.0.4 (2005.06.17), 1.0.5 (2005.09.09).
- 0.9.0 (2003.07.08), 0.9.1 (2003.09.04), 0.9.2 (2003.10.15), 0.9.3 (2003.11.20)
- 0.8 (2002.11.18), 0.8.1 (2002.12.11).
- 0.7 (2002.07.26), 0.7.1 (2002.09.10).
- 0.6 (2002.07.03).
- 0.5 (2002.03.15).
- 0.4 (2001.12.17).
- 0.3 (2001.10.10).
- 0.2 (2001.07.31).
- 0.1 (2001.05.07).
Daily Builds
There are two other methods of getting FreeRADIUS: Downloading a source tarball (either of a release or of a nightly CVS snapshot) or using CVS to download the latest development version.
One should be careful of the daily builds, as the server is under active development. The CVS builds may not even compile, much less work as one hopes, so unless you're curious, or if you want to help further develop the server, you should almost certainly choose to obtain the latest released version from the top of the list, above.
Manual Pages
The top-level README and INSTALL files contain instructions for configuring and installing the server. Additional documentation is found on the usage page, or in the man pages.
If the server is installed properly on your local system, you should
be able to type man rlm_foo
to see the "man" page for the
module "foo".
Not all modules have "man" pages, so please read radiusd.conf for additional documentation.