mtcp_init − initialize the mTCP stack.
#include <mtcp_api.h>
int mtcp_init(char *config_file);
mtcp_init() call is used to set the stack parameters of an mTCP-based application. These parameters are loaded inside the process via a startup configuration file. A developer is required to first call mtcp_init() function before he/she can invoke any follow-up mTCP functions in his/her application.
A user can populate an mTCP configuration file with the following parameters:
|
io |
The underlying I/O driver he/she wants to use for his/her application. A user can specify either dpdk or psio (but not both) as the choice of the network I/O driver. Please note that psio is only supported for linux-2.6.32~linux-2.6.38 kernels. | ||
|
num_cores |
The number of cores one needs to use to run the mTCP application. Each core will spawn a pair of mTCP core thread and mTCP application thread. This variable is also used to set the number of RSS-based NIC hardware queues based on which traffic is split across different mTCP core threads in the application. It is assumed that each mTCP thread only reads from one hardware queue per NIC. | ||
|
num_mem_ch |
The number of memory channels that are currently inserted in the CPU per socket. Note that this option is used only for dpdk I/O driver. Default value is 0. | ||
|
port |
Space-separated NIC port(s) (specified as interface names) that will be used by the mTCP application. | ||
|
max_concurrency |
Maximum number of concurrent connections that can be accomodated by the mTCP stack per-core. Default value is 100000 connections per core. | ||
|
rcvbuf |
Receive buffer size of each mTCP socket. Default value is 8192 bytes. | ||
|
sndbuf |
Send buffer size of each mTCP socket. Default value is 8192 bytes. | ||
|
tcp_timeout |
TCP timeout (in seconds) of a connection. Default value is 30 seconds. Putting the value as -1 disables the timeout check. | ||
|
tcp_timewait |
TCP timewait value (in seconds). Default value is 0 seconds. | ||
|
stat_print |
Per-second traffic statistics printing of the specified interface. |
Returns 0 on success; -1 on failure.
See config/sample_mtcp.conf to view example startup mTCP configuration file. Make sure that the mTCP configuration file has a specified I/O driver. Also make sure that num_mem_ch value is appropriately set when dpdk driver is being used.
mTCP development team<EMAIL_ADDRESS>mtcp_destroy()
This page is part of mTCP release 3.0 docs section. A description of the project, and information about reporting bugs, can be found at http://shader.kaist.edu/mtcp/.


UKCloud Limited (“UKC”) and Virtual Infrastructure Group Limited (“VIG”) (together “the Companies”) – in Compulsory Liquidation
On 25 October 2022, the Companies were placed into Liquidation with the Official Receiver appointed as Liquidator and J Robinson and A M Hudson simultaneously appointed as Special Managers to manage the liquidation process on behalf of the Official Receiver.
Further information regarding the Liquidations can be found here: https://www.gov.uk/government/news/virtual-infrastructure-group-limited-and-ukcloud-limited-information-for-creditors-and-interested-parties
Contact details:
For any general queries relating to the Liquidations please email<EMAIL_ADDRESS>For customer related queries please email<EMAIL_ADDRESS>For supplier related queries please email<EMAIL_ADDRESS>Snapshot Protection
About this document
This document explains what is and isn't included in the scope of the Snapshot Protection service option.
Snapshot Protection is one of a variety of on‑platform protection options available from UKCloud. Use this service scope to understand Snapshot Protection and whether it will meet your own recovery point (RPO) or recovery time (RTO) objectives.
About Snapshot Protection
UKCloud offers a choice of snapshot options that operate as a daily backup service for customers using our VMware‑based compute services.
You can choose from the following Snapshot Protection policies:
14‑day snapshot
28‑day snapshot
When you opt a virtual machine (VM) into a Snapshot Protection policy, the VM is added to a daily automated snapshot. The snapshot is of the entire VM running on your UKCloud for VMware service.
Data protected by the snapshot has an RPO of 24 hours. RTO is determined by the time taken to restore the VM after you've raised a Service Request.
Snapshot Protection is chargeable based on the number of VMs protected and the capacity utilised to store the data.
No protection products are automatically applied to VMs running on the UKCloud platform, therefore you must explicitly select the protection option that best meets your requirements.
Frequency and timing
Snapshots are scheduled to occur once in a 24-hour period.
Snapshots take place 365 days of the year and are started inside the UKCloud‑defined window: 20:00-08:00. Snapshots are not started before 20:00 or after 08:00.
We cannot guarantee the time at which your VM will have a snapshot taken inside this window; the time may also vary from day to day. The time of a snapshot is reported via the UKCloud Portal the next day.
There's a system hard stop at 09:00, at which time any active snapshots are cancelled.
Due to the higher rate of new data on a VM's initial snapshot backup, each new VM is automatically configured with 'overtime' enabled on it's first backup. This enables it to run to successful completion beyond the standard backup window (20:00-08:00) if required. This helps to ensure the initial backup completes on the first attempt, particularly for large or high change rate VMs. The flag is removed after the first successful backup.
Success rate
We do not guarantee successful snapshots.
We can provide you with guidance on suitable candidates for Snapshot Protection (data change rate/size).
For regions 1, 2, 7 and 8, large VMs (2 TiB+) with high change rates are not recommended for Snapshot Protection, as the service will spend longer trying to establish what has changed and then attempt to back all of it up. You should take an alternative backup approach with VMs of this size in these regions.
For regions 5, 6, 13 and 14, you can use Snapshot Protection for large VMs. However, you should still consider the impact of recovery time for large VMs.
VM snapshots may be attempted more than once to obtain successful status.
Only the final state will count in our calculations.
Partial snapshots and those with errors count as failed.
Any snapshots still in progress at 09:00 are considered as failed.
Due to the higher rate of new data on a VM's initial snapshot backup, each new VM is automatically configured with 'overtime' enabled on it's first backup. This enables it to run to successful completion beyond the standard backup window (20:00-08:00) if required. This helps to ensure the initial backup completes on the first attempt, particularly for large or high change rate VMs. The flag is removed after the first successful backup.
Reruns
We may attempt to rerun a failed snapshot inside the window, depending on the failure code.
We will not rerun snapshots outside the window.
What SLA do you offer on snapshot success?
Automated VM snapshots don't include an SLA. You should be aware that snapshots may occasionally fail for a variety of reasons. The status of automated VM snapshots is monitored continuously, and the UKCloud support team investigates all failures.
It isn't always possible to rerun an automated VM snapshot, if this service doesn't meet your own protection requirements, we can also offer Journaling Protection options.
If none of these services meet your requirements, you can also implement and manage your own protection solution.
The UKCloud Cloud Storage platform may be an appropriate target for self‑managed solutions using software such as CommVault and NetWorker.
The service is not backed by service credits.
Planned Maintenance
On occasion, Planned Maintenance will take precedence over VM snapshots. If there's a potential disruption, we'll highlight this to you via the UKCloud Service Status page.
Snapshot management
You can make changes to your Snapshot Protection via the UKCloud Portal. You can:
Opt VMs into Snapshot Protection
Change the Snapshot Protection policy for a VM
Opt VMs out of Snapshot Protection
Set a default Snapshot Protection policy for a VDC
Alerting and reporting
Information about your backups is reported on the UKCloud Portal. Reports are updated daily and are available by 10:00, but typically within minutes of the close of the backup window.
Reports are available covering every day of the retention period (14 or 28 days as appropriate).
Alerting on individual VMs is not provided.
Restores
Timing and process
You can ask to restore a VM by raising a Service Request via the My Calls section of the UKCloud Portal, which is subject to standard support SLA timescales.
Restores are performed outside of the backup window, unless a P1 incident is involved. You can find a definition of our support processes and severity categorisation in Raising and escalating support tickets with customer support.
What you get
We'll instantiate a new VM. This will incur additional storage charges.
We'll provide an image from a successful snapshot of your choice from within the policy length (that is, the last 14 or 28 days).
You'll need to make any necessary switchover/networking changes.
Fair use policy
You can request up to four restores per month. If you request more than this, we will suggest a Cloud Architect investigate.
The total number of VMs (or disks) in a restore request should not exceed five.
KPIs
We'll proactively investigate failures on the platform on the following triggers:
Individual customer VM:
Two successive snapshot window failures
A failure of three snapshots in 14 days
Platform:
More than 50 missed VMs (VMs that should be in policy, but have not been backed up)
Less than 99% success rate for VM snapshot
Feedback
If you find a problem with this article, click Improve this Doc to make the change yourself or raise an issue in GitHub. If you have an idea for how we could improve any of our services, send an email to feedback@ukcloud.com.


A Performer
As a performer, I enjoy playing multitude of styles of music written for flute. I particularly adore studying Baroque music and its improvisational style, something that is sadly missing from the modern classical flute playing. I also enjoy playing and learning the new extended techniques that go beyond the traditional idea of flute playing, such as singing and playing, beatboxing, and other ways to produce sound with flute.
I have had good fortune to be a featured soloist at various orchestras, and to play with many different groups. My dream is to bring classical music closer and more accessible to the general public, stepping out of its former (and formal) ways, often associated with eliticism.
A Teacher
We all know the question, "what do you want to be when you grow up?" When I was asked the question for the first time in the kindergarden, I answered "teacher," and it still holds true years later. I have been teaching in some capacity or another ever since college, and I have experience as a math tutor, a volunteer trainer, and of course, a flute teacher, as well as teaching my cat to perform various tricks.
I aim to teach holistically, so students not only learn the techniques and the materials for developing their flute playing, but also the whys and the context that goes along with it. I firmly believe that background information is just as important, if not more, in cultivating the big picture understanding of music making that will allow the student to be self-sufficient and motivate to teach themselves even without the teacher.
A Repair Technician
A graduate of Minnesota State College - Souteast's Band Instrument Repair Program, I worked as a woodwind repair technician, servicing small woodwind instruments. The precise and the intricate nature of the trade opened my eyes to appreciate the precise machines that are musical instruments, and the craftmanship and the love that goes into manufacturing even the student level instruments.


{% extends '../layouts/template.html' %} {% block title %}Check my State Pension - {{mvpversion}}{% endblock %} {% block serviceName %}Check your State Pension{% endblock %} {% block main %}
You can get your State Pension on 1 December 2020 when you’ll be 66, your forecast is
£140.65 a week
£609.48 a month, £7,313.80 a year
Your forecast
When you reach State Pension age in 2020, you no longer have to pay National Insurance contributions.


--- layout: archive title: Zulip Chat Archive permalink: /stream/113488-general/topic/Reference.20Manual.html ---
I saw The Lean Reference Manual and I found a description of inductive type declaration which I could not understand.
https://leanprover.github.io/reference/declarations.html#inductive-types
This is a quote from 4.4 Inductive Types in the document.
Suppose the telescope (b : βᵢ) is (b₁ : βᵢ₁) ... (bᵤ : βᵢᵤ). Each argument in the telescope is either nonrecursive or recursive. An argument (bⱼ : βᵢⱼ) is nonrecursive if βᵢⱼ does not refer to foo, the inductive type being defined. In that case, βᵢⱼ can be any type, so long as it does not refer to any nonrecursive arguments. An argument (bⱼ : βᵢⱼ) is recursive if it βᵢⱼ of the form Π (d : δ), foo where (d : δ) is a telescope which does not refer to foo or any nonrecursive arguments.
This description says that each argument in the telescope is either nonrecursive or recursive.
I can not get from the following statements even whether or not nonrecursive and recursive arguments are mutually exclusive.
My intuition tells recursive argument
means that it refer to foo
itself in some sense.
But these statements seem to say that none of the arguments refer to foo
.
nonrecursive and recursive are mutually exclusive and exhaustive of the arguments to a constructor
Recursive means it has the form Π (d : δ), foo
, so it clearly refers to foo
and hence it cannot be nonrecursive
If an argument fits neither description (neither nonrecursive nor recursive), for example foo -> foo
, then it is not allowed as a constructor argument at all
The rule says that (d : δ)
is a telescope that does not refer to foo, so the only appearance of foo
in Π (d : δ), foo
is the one at the end
so the only appearance of foo in Π (d : δ), foo is the one at the end
Oh, I have missed foo
in Π (d : δ), foo
. I understood. Thank you!
Last updated: Apr 24 2020 at 19:02 UTC


---
layout: post
title: Silverlight Flash whatEva
---
{{ page.title }}
. 21 February 2010 - Johannesburg
I've recently had to do a website for a client. She had a lot of really creative ideas and wanted some nice effects. Initially I thought to be able to create the effects she wanted I would have to use Silverlight or Flash. Neither of them I am that familiar with.
After some investigation into javascript I was blown away by the sheer power of it and the great plugins people had written for it. I have only done some minor javascript work so I was not that famliar with it. But it was really easy to get going using the powerful plugins written and using jQuery makes it just plain sweet.
Plugins I used:
- jQuery The awesomeness.. need I say more.
- Yahoo CSS reset This is the first time I have used a css reset. I really liked it and I found it helped me with the website design
- The anything slider was used to slide between sections in the website.
- The lightBox plugin was used to display the pictures in the gallery. This had great flexibility to resize the images and had a really classy feel and suited the website perfectly.
Before starting this I was quite naive and thought to get a website with fades and dynamic effects I needed Silverlight or Flash. I now realize that this is not true. I think that in most cases with web design, css and javascript is the way to go. Its easy to use, it works with most browsers including iphone and uncomplicated.
I have seen some great sites developed with Flash and Silverlight but now I really dont see a reason to learn either technology. After trying to get to learn Silverlight a while back and getting very stuck with XAML, most of it can be replicated in javascript and the learning curve is not as steep.
So moral of the story, javascript combined with the power of jQuery gets my stamp of approval
Oh yes, please check out the site and let me know what you think...
link


?JARDIN
BOTANICO
NACIONAL
"DR.
RAFAEL
M.
MOSCOSO"
SANTO
DOMINGO,
REPUBLICA
DOMINICANA
NO.
Io22LFAMtuA_Poaceae_
Cenchrua
brownii
R.
&
S.
0.5
m.
tall.
República
Dominicana;
Prov.
San
Cristóbal:
Arroyo
La
Toma
and
Balneario
La
Tomat
being
9
km.
N
of
main
plaza
of
San
Cristobal
on
road
to
Medina;
humid
ravine
with
stream
and
springs,
once
famous
resort
but
now
water
pump
houses
and
low
abusive
usage.
I8»27'N,
70007'V,
alt.
60
to
100
m.
January
15»
1981.
M.
Mejia,
C,
Ramirez,
T.
Zanoni.
01530229
Legend -
Level of confidence that token is an accurately-transcribed word
extremely low
very low
low
undetermined
medium
high
very high


me
polkadot
A short list of writings on Polkadot.
slashing in era 51
, sometimes the stars don't align


Good luck!
William Nylander has a younger brother that is also a very talented hockey player - What´s his name?
Which of the following ingredients is usually NOT included in a Pasta Carbonara?
What is the next word in this lyric from a Eurovision winner-song? "We are the heroes of our time, but we're...."
You hit you first serve in the net in a tennis match - What happens?
What number does my favourite hockey player Oliver Ekman Larsson have on his shirt in Arizona Coyotes?
What is the name of the bar/club at Scheelegatan 8 in Stockholm where you can dance to schlager and old hits?
How many (unwanted) points do you get if you get the queen of spades in the cardgame Hearts?
What liquor is used in a Bloody Mary?
Who made the winning goal when Sweden won the Junior World Championship in hockey 2012?
Who took the most medals for the Swedish Cross country ski team in the 2017 World Championship?
Show me how I did!
Question 1: The correct answer is Alexander.
Question 2: The correct answer is Tomatoes.
Question 3: The correct answer is dancing.
Question 4: The correct answer is Don't worry, you have one more chance to do a correct serve.
Question 5: The correct answer is 23.
Question 6: The correct answer is Lemon.
Question 7: The correct answer is 13.
Question 8: The correct answer is Vodka.
Question 9: The correct answer is Mika Zibanejad.
Question 10: The correct answer is Charlotte Kalla.
You answered them all right!


Item One
Item Two
Item Three
Item Four
Tabs enable content organization at a high level, such as switching between views, data sets, or functional aspects of an app.
Tabs enable content organization at a high level, such as switching between views, data sets, or functional aspects of an app.
Present tabs as a single row above their associated content. Tab labels should succinctly describe the content within.
Because swipe gestures are used for navigating between tabs, don't pair tabs with content that also supports swiping.


services
Interfaces
BotanicSystemService
BowlService
CustomerService
ExhibitionService
GeoRegionService
ManufactureService
PartnerService
RoadmapService
SettingService
SoftwareService
StatusService
TimberOriginService
TimberService
Classes
AbstractService
BotanicSystemServiceImpl
BowlServiceImpl
CustomerServiceImpl
ExhibitionServiceImpl
GeoRegionServiceImpl
ManufactureServiceImpl
PartnerServiceImpl
RoadmapServiceImpl
SettingServiceImpl
SoftwareServiceImpl
StatusServiceImpl
TimberOriginServiceImpl
TimberServiceImpl


Package com.welie.blessed
Class BluetoothCentralManagerCallback
- java.lang.Object
-
- com.welie.blessed.BluetoothCentralManagerCallback
-
public abstract class BluetoothCentralManagerCallback extends java.lang.Object
Callbacks for the BluetoothCentralManager class
-
-
Constructor Summary
Constructors Constructor Description BluetoothCentralManagerCallback()
-
Method Summary
All Methods Instance Methods Concrete Methods Modifier and Type Method Description void
onBluetoothAdapterStateChanged(int state)
Bluetooth adapter status changedvoid
onConnectedPeripheral(@NotNull BluetoothPeripheral peripheral)
Successfully connected with a peripheral.void
onConnectionFailed(@NotNull BluetoothPeripheral peripheral, @NotNull HciStatus status)
Connecting with the peripheral has failed.void
onDisconnectedPeripheral(@NotNull BluetoothPeripheral peripheral, @NotNull HciStatus status)
Peripheral disconnectedvoid
onDiscoveredPeripheral(@NotNull BluetoothPeripheral peripheral, @NotNull android.bluetooth.le.ScanResult scanResult)
Discovered a peripheralvoid
onScanFailed(@NotNull ScanFailure scanFailure)
Scanning failed
-
-
-
Method Detail
-
onConnectedPeripheral
public void onConnectedPeripheral(@NotNull @NotNull BluetoothPeripheral peripheral)
Successfully connected with a peripheral.- Parameters:
peripheral
- the peripheral that was connected.
-
onConnectionFailed
public void onConnectionFailed(@NotNull @NotNull BluetoothPeripheral peripheral, @NotNull @NotNull HciStatus status)
Connecting with the peripheral has failed.- Parameters:
peripheral
- the peripheral for which the connection was attemptedstatus
- the status code for the connection failure
-
onDisconnectedPeripheral
public void onDisconnectedPeripheral(@NotNull @NotNull BluetoothPeripheral peripheral, @NotNull @NotNull HciStatus status)
Peripheral disconnected- Parameters:
peripheral
- the peripheral that disconnected.status
- the status code for the disconnection
-
onDiscoveredPeripheral
public void onDiscoveredPeripheral(@NotNull @NotNull BluetoothPeripheral peripheral, @NotNull @NotNull android.bluetooth.le.ScanResult scanResult)
Discovered a peripheral- Parameters:
peripheral
- the peripheral that was foundscanResult
- the scanResult describing the peripheral
-
onScanFailed
public void onScanFailed(@NotNull @NotNull ScanFailure scanFailure)
Scanning failed- Parameters:
scanFailure
- the status code for the scanning failure
-
onBluetoothAdapterStateChanged
public void onBluetoothAdapterStateChanged(int state)
Bluetooth adapter status changed- Parameters:
state
- the current status code for the adapter
-
-


Author: Jeremy
I was trying to make fancy potatoes, but got caught up in the music I was listening to... pretty sure I just did what the song told me and didn't follow the recipe, and now the flag is baked in. Can you get it out?
Download to help fix these potatoes!


For the core compiler project, you will complete a non-optimizing compiler for the TL13 language. The resulting compiler should translate TL13 source code, producing output at several intermediate stages, into MIPS assembly code executable in the SPIM simulator.
Make sure you pay attention to the requirements listed under Input/Output specification below. Programs must comply with those specifications to receive full credit.
Your first assignment is to write a Scanner and Parser for the TL13 language. A BNF grammar and a list of lexical items for the TL13 language is provided. If you wish, you may use an automated tool, such as lex, to create the code for your scanner, but since everything is separated by whitespace, you may find that for TL13 it is simpler to write an ad-hoc scanner by hand or using standard Java library calls (hint: look at the methods provided by java.lang.String).
The TL13 language is intended to be LL(1), and you are required to write, "by hand," a predictive recursive-descent top-down parser for it. You may modify the grammar to make it LL(1). Your parser should have one method or function corresponding to each non-terminal in the language's (modified) grammar.
For a lexically or syntactically invalid program, your scanner or parser should output an appropriate error message.
For a syntactically valid input program, the your parser should output a Graphviz DOT file containing either the program's parse tree or the program's AST (as required in the next step).
You should modify your parser to produce an Abstract Syntax Tree (AST) as a tree data structure in memory. It is a requirement that you create the abstract syntax tree as a tree data structure in memory. You will not receive full credit.
Note: you do not want to generate your AST by first generating the parse tree and then deleting nodes. You want to create the AST directly and inductively during the recursive descent parsing.
Hint: If you are using Java, you may find it useful to provide a Visitor interface for processing the different subclasses of AST nodes in the in-memroy data structure. (In this case, one Visitor might be for printing out graphviz nodes for AST Nodes. Another might be for decorating the AST with types and doing type checking.) If you are using Scala, you will find that pattern matching provides the same organization, but is much more concise.
Once you have generated the AST. The compiler should traverse the AST to find the type of each subexpression and determine whether there are any violations of the TL13 type rules.
Hints: In order to type check the program, you will need to create a symbol table to associate each appearance of a variable with that variables declared type. The best way to do this, is probably to create an entry in a hash table indexed by name and containing information about each declared entity. (For TL13, it is sufficient to just track the name and type of each declared variable.) And then when the AST generation code comes across a variable in a procedure body, it can look that name up in the symbol table and store a pointer/reference to that symbol table entry in the AST node.
The compiler should traverse the abstract syntax tree and translate the program into basic blocks of three-address ILOC instructions [Section 5.3.2, Section 5.3.3, and Appendix A of Cooper] according to the TL13 semantics. You may add instructions beyond those described in Cooper. Specifically, you may wish to add mod, readInt, and writeInt instructions. As in the examples found in Cooper, each basic block should end in a conditional branch or unconditional branch (a.k.a., jump). The ILOC code can use an infinite number of virtual registers.
Hints:
As the last step, the "back end" of the compiler should translate the program into executable MIPS assembly code. This involves selecting the appropriate MIPS assembly language instructions, modifying the code so that it executes with a finite number of registers, and outputting an ASCII file containing MIPS assembly code that is executable with SPIM.
The ILOC and MIPS instruction sets are quite similar, and depending on the subset of ILOC which the IR contains, instruction selection may be done through a simple 1:1 substitution of MIPS instructions for ILOC instructions. (Please refer to Appendix A of Computer Organization and Design: The Hardware/Software Interface for a description of the MIPS Instruction Set Architecture (ISA), the MIPS assembly language, and the SPIM simulator.) It may be necessary, however, to handle some instructions in a slightly more complicated manner. (For example, the MIPS load-from-memory instruction takes a "register + a 16 bit constant offset" as its address, and it is not possible to map ILOC's loadAO instruction directly to it.) Note: SPIM provides simulated system calls for printing out characters; you may find the read_int, print_int, and print_char system calls useful for implementing TL13's readInt and writeInt operations. You may wish to use an instruction selection scheme based on the peephole optimization to handle these cases. (Cf. Section 11.4 of Engineering a Compiler, but you can probably simplify the scheme described there.)
In order to generate executable MIPS code, however, you will have to generate code that uses only those registers available in the MIPS ISA. Normally this would be done using graph-coloring register allocator with spilling; implementing this will be an extension. In order to get executable code without a register allocator, you can add a "dummy register allocator pass" that simply sets aside dedicated registers for the input and output of each MIPS instruction, and creates one global variable (in the ".data" segment or as an offset from the frame pointer) for each IR temporary. You would then place a store instruction to write to that global variable, each time it the temporary is assigned to, and place load instructions to transfer the data back from the global variables into the dedicated registers for each MIPS instruction. This implementation would be quite inefficient, but it will produce correct code. See the simple1.s as an example of the output this process would produce. (An alternative, which you may also pursue would be to only use a limited set of registers in the ILOC code and to instead assign a fixed memory location to each variable/temporary and perform loads/stores as appropriate in the ILOC code.)
The compiler program should expect a TL13 input file,
<basename>.tl13
, to be specified as
command-line argument when it is invoked. (See language-specific
submission instructions in the getting
stated document for details.)
If the input file is not a syntactically-valid program (i.e., if the program contains a lexical element that is not a legal token or does not match the BNF grammar), the compiler should ouptut an error message to standard error (System.err in Java) containing the text "SCANNER ERROR", the text "PARSER ERROR", or the text "SYNTAX ERROR". (There is no constraint on which you use. The intent is that you might want to distinguish between scanner and parser errors or you might want to just call everything a syntax error.)
The compiler may optionally, output a parse tree in graphviz dot
format to the file: <basename>.pt.dot
(The output requirements of the "Recursive Descent Parser" item in the
rubric may be satisfied with this parse tree or by an AST meeting the
requirements in the next section.)
If there is no syntax error, the compiler should output an abstract
syntax tree in graphviz dot format to the AST output file,
<basename>.ast.dot
. The nodes of the abstract
syntax tree that serve as the roots of subexpressions whose type is INT
should have a fillcolor of "/pastel13/3"
(a light green)
and those whose type is BOOL should have a fillcolor of
"/pastel13/2"
(a light blue). If there is a type error, the
compiler should output an error message to standard error that contains
the text "TYPE ERROR" and should also color the AST
node associated with that type error (e.g., the node of an operation whose
operands have incorrect types) "/pastel13/1"
(a pink) in the AST output file.
If there is no syntax or type error, the compiler should also output
a control flow graph in graphviz dot format to the file,
<basename>.iloc.cfg.dot
. The control flow graph
should be based on a translation of the original program into an ILOC
three-address code. The nodes in the graph should be the basic blocks
of the ILOC program representation. In the graphviz output, each of
the nodes of the graph should be labeled with the instructions found
in that basic block. (Optionally, one may also create a text file
<basename>.iloc.txt
containing just the iloc
instructions, so that they can be evaluated even if the control flow
graph output does not work correctly.)
The final output of the compiler,
SPIM-compatible MIPS
assembly code that faithfully implements the semantics of
the original source program, should be written to the file,
<basename>.s
.
So for a correct TL13 source program,
<basename>.tl13
, the compiler should produce
a Type-annotated Abstract Syntax Tree
(<basename>.ast.dot
), a control flow graph
(<basename>.iloc.cfg.dot
), and a MIPS assembly
code file (<basename>.s
). Optionally,
it may also produce a parse tree,
<basename>.pt.dot
.
The entire compiler should be complete and operating correctly by the final deadline. "Rough drafts" of the compiler are due at three intermediate deadlines: "Review 1", "Review 2", and "Review 3". These deadlines exist to encourage students to make timely progress and to provide an opportunity for the TA and/or instructor to review the code and provide feedback. To receive full-credt, students should aim to have at least parsing and parse-tree output completed by "Review I"; additionally have AST generation, type checking, and AST output completed by "Review II"; and additionally have ILOC translation and CFG output completed by "Review III".
Please refer to the Grading Rubric available in blackboard.
You are also required to adequately test your compiler and submit your test cases along with your source code and document the current state of your compiler based on your own testing. Include both incorrectly-typed programs and correctly-typed programs that exercise all parts of your compiler.
The following some sample input TL13 programs and (for some) their corresponding output files. Nota bene: it is not necessary to match the text of the dot files exactly. It is only necessary to produce dot files that visually complies with the specification above when rendered with graphviz. For MIPS, it is only necessary to produce programs that behave in accordance with the TL13 semantics when executed.
The input file will be specified as a command-line argument. Output file names should be based on the input command-line argument. Details about how the program will be invoked are contained in the "Getting Started" document.
There may need to be corrections, clarifications, or other modifications to these instructions, you are responsible for monitoring the class web site and listening during lecture for announcements related to this assignment.


Jexler is a simple relaxed Groovy framework for starting/stopping Groovy scripts as services and enabling them to react to events of their choice - great for prototyping and useful for automating. - User Guide / Screenshot - Source at Github - jexler-core (JAR) at Maven Central - jexler GUI (WAR) at Sourceforge - Groovydoc / JaCoCo (understates Groovy coverage) other: - httest binaries (built with jexler)


This example shows multiple simple color matrix filters used with an Openlayers 3 map. The filter can be chained.


bbclib.libs.bbclib_keypair module¶
Copyright (c) 2018 beyond-blockchain.org.
Licensed under the Apache License, Version 2.0 (the “License”); you may not use this file except in compliance with the License. You may obtain a copy of the License at
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
-
bbclib.libs.bbclib_keypair.
KeyPair
¶ alias of
bbclib.libs.bbclib_keypair.KeyPairPy
-
class
bbclib.libs.bbclib_keypair.
KeyPairPy
(curvetype=2, compression=False, privkey=None, pubkey=None)[source]¶ Bases:
object
-
POINT_CONVERSION_COMPRESSED
= 2¶
-
POINT_CONVERSION_UNCOMPRESSED
= 4¶ Key pair container
-
import_publickey_cert_pem
(cert_pemstring, privkey_pemstring=None)[source]¶ Verify and import X509 public key certificate in pem format
-
mk_keyobj_from_private_key
(privkey)[source]¶ Make a keypair object from the binary data of private key
-
mk_keyobj_from_private_key_der
(derdat)[source]¶ Make a keypair object from the private key in DER format
-
mk_keyobj_from_private_key_pem
(pemdat_string)[source]¶ Make a keypair object from the private key in PEM format
-


--- layout: page title: Lean Prover Zulip Chat Archive permalink: archive/113488general/38749maximalminimalelements.html ---
Does the definition of maximal/minimal elements in a preorder exist in mathlib?
In order.bounds
least/greatest elements are defined, but I cannot find maximal/minimal elements.
Recall that x
is a maximal element of a set s
if x
is in s
and no y
in s
satisfies y > x
.
This definition could also be used to define ideal.is_maximal


Ampe, a rhythmic girls' game from Ghana, includes clapping, jumping, dancing, singing activities and a particular fashion style, helping bond communities.
The style of clothes is very important to the game of Ampe. Most important of all is that each girl should wear a short and tight skirt facilitating the necessary movement of the legs.Ampe had traditionally been a form of entertainment that many would enjoy at organised events. Ampe was either an addition to a ceremony or as an event on its own.


Fun Awaits
Future Proof strives to make games that last. We focus on mechanics that are geniunely fun to play, and prioritize the player's experience to guide our design. We also believe in challenging players, because the most rewarding experience comes from critically analyzing and overcoming situations with intent.


beauty is applied first to theorems, then to proofs
then to “a brilliant step” in an otherwise undistinguished proof
“An example of mathematical beauty upon which all mathematiciansagree is Picard’s theorem, asserting that an entire function of a complexvariable takes all values with at most one exception. The limpid statementof this theorem is matched by the beauty of the five-line proof providedby Picard”
he gives a lot of examples of theorems/proofs being beautiful
“This agreement is notmerely the perception of an aesthetic quality superimposed on the contentof a piece of mathematics. A piece of mathematics that is agreed to be beau-tiful is more likely to be included in school curricula; the discoverer of abeautiful theorem is rewarded by promotions and awards; a beautiful argu-ment will be imitated. In other words, the beauty of a piece of mathematicsdoes not consist merely of the subjective feelings experienced by anobserver. The beauty of a theorem is an objective property on a par withits truth. The truth of a theorem does not differ from its beauty by a greaterdegree of objectivity.”
mathematics are very aware that beauty is context-dependent
“ne can characterize a mathematical paper as “cre-ative” only after the paper has been understood. It is, however, impossibleto produce on commission a “creatively” written mathematical paper”
“AAppreciation of mathematical beauty requiresfamiliarity with a mathematical theory, which is arrived at at the cost of time, effort, exercise, and Sitzfleischrather than by training in beautyappreciation.”
“There is a difference between mathematical beauty and mathematicalelegance. Although one cannot strive for mathematical beauty, one canachieve elegance in the presentation of mathematics. In preparing to delivera mathematics lecture, mathematicians often choose to stress elegance andsucceed in recasting the material in a fashion that everyone will agree iselegant. Mathematical elegance has to do with the presentation of mathe-matics, and only tangentially does it relate to its content. A beautifulproof can be presented elegantly or not”
lack of beauty is related to lack of definitiveness
Mathematicians seldom use the word “ugly.” In its place are such dis-paraging terms as “clumsy,” “awkward,” “obscure,” “redundant,” and, inthe case of proofs, “technical,” “auxiliary,” and “pointless.” But the mostfrequent expression of condemnation is the rhetorical question, “What isthis good for?”
“The beauty of a piece of mathematics is frequently associated with short-ness of statement or of proof”
“A proof is viewedas beautiful only after one is made aware of previous, clumsier proofs.”
“But when mathematicaltheorems from disparate areas are strung together and presented as “pearls,”they are likely to be appreciated only by those who are already familiarwith them.” -> programming pearls
“The mathematician who is baffled and asks “What is thisgood for?” is missing the senseof the statement that has been verified to betrue. Verification alone does not give us a clue as to the role of a statementwithin the theory; it does not explain the relevanceof the statement. Inshort, the logical truth of a statement does not enlighten us as to the senseof the statement. Enlightenment, not truth, is what the mathematician seekswhen asking, “What is this good for?” Enlightenment is a feature of math-ematics about which very little has been written.”
ENLIGHTENMENT -> understanding


To display and hide content, you can use rxCollapse. It can be set as either expanded or collapsed on page load. A double chevron is used as a toggle to show/hide the inner contents, while keeping the header and border visible.
In areas where metadata needs to be available but space is limited, you can use a "See More"/"See Less" link to expand and show additional metadata. The most relevant lines of metadata should display on page load with less relevant lines of metadata hidden behind "See More".


Fork me on GitHub
Upload zip file
Download Data
Preview
TestData Source
geojpg.zip
.
Cancel
Loading
Error Messages
Sorry, this format are not supported.
Cancel


| Name |
Description |
|
ThermodynamicState |
Thermodynamic state of ideal gas |
|
BaseProperties |
Base properties of ideal gas |
|
setState_pTX |
Return thermodynamic state from p, T, and X or Xi |
|
setState_phX |
Return thermodynamic state from p, h, and X or Xi |
|
setState_psX |
Return thermodynamic state from p, s, and X or Xi |
|
setState_dTX |
Return thermodynamic state from d, T, and X or Xi |
|
setSmoothState |
Return thermodynamic state so that it smoothly approximates: if
x > 0 then state_a else state_b |
|
pressure |
Return pressure of ideal gas |
|
temperature |
Return temperature of ideal gas |
|
density |
Return density of ideal gas |
|
specificEnthalpy |
Return specific enthalpy |
|
specificInternalEnergy |
Return specific internal energy |
|
specificEntropy |
Return specific entropy |
|
specificGibbsEnergy |
Return specific Gibbs energy |
|
specificHelmholtzEnergy |
Return specific Helmholtz energy |
|
dynamicViscosity |
Return dynamic viscosity |
|
thermalConductivity |
Return thermal conductivity |
|
specificHeatCapacityCp |
Return specific heat capacity at constant pressure |
|
specificHeatCapacityCv |
Return specific heat capacity at constant volume |
|
isentropicExponent |
Return isentropic exponent |
|
velocityOfSound |
Return velocity of sound |
|
specificEnthalpy_pTX |
Return specific enthalpy from p, T, and X or Xi |
|
temperature_phX |
Return temperature from p, h, and X or Xi |
|
density_phX |
Return density from p, h, and X or Xi |
|
isentropicEnthalpy |
Return isentropic enthalpy |
|
isobaricExpansionCoefficient |
Returns overall the isobaric expansion coefficient beta |
|
isothermalCompressibility |
Returns overall the isothermal compressibility factor |
|
density_derp_T |
Returns the partial derivative of density with respect to
pressure at constant temperature |
|
density_derT_p |
Returns the partial derivative of density with respect to
temperature at constant pressure |
|
density_derX |
Returns the partial derivative of density with respect to mass
fractions at constant pressure and temperature |
|
molarMass |
Returns the molar mass of the medium |


Your browser does not support the HTML5 canvas tag.
Age
Gender:
Female
Male
Title:
Lowborn
Baron/Baroness
Count/Countess
Duke/Duchess
King/Queen
Emperor/Empress
Race:
Human
Halfling
Dwarf
Elf
Half-Elf
Half-Orc
Seed
Randomize Portrait
Render
Image copyright Paradox Interactive. All rights reserved.


About Me
My name is Jamie and I work in the medical field, specifically physical therapy. I am interested in learning web development as a skill.
I plan to begin freelancing in full stack web development and using this to supplement my income by working from home.
After gaining some experience with freelance jobs, I would like to transition to working full-time within the web development and programming space. I especially am interested in web development in the healthcare and financial industries.


This chart shows the sales in California as well as the projected sales through 2015.
This chart shows the total profit in California broken down by category.
This chart shows the breakdown of profit in California.
This chart shows the profit broken down by state.


Case Study 1: Power Flow Simulation
A contingency analysis done on U.S. power grid system using an AC power flow model developed using DMNetwork. The input file was obtained from the MatPower package (matpower.org). The total numbers of buses, generators, loads, and branches are 82,000, 13,419, 37,755, and 104,121 respectively. The total number of unknowns solved is around half million. The scaling results shows that doubling the number of compute nodes doubled the speedup. Increasing the number of cores from 128 to 2048, provided a speedup of twelve. Poster
Case Study 2: River Flow Simulation
A river flow simulation done on the U.S. river networks using DMNetwork. The input file was obtained from the NHDPlus dataset (horizon-systems.com). The total numbers of reaches and junctions are 3098638 and 3036092, respectively. The total number of unknowns solved is around a half a billion. Increasing the number of cores from 1,024 to 65,536, provided a speedup of 35. Poster


--- layout: archive title: Zulip Chat Archive permalink: /stream/144837-PR-reviews/topic/.23422.20limits.20in.20CommRing.html ---
@Patrick Massot, I've started a WIP branch to construct products and equalizers in CommRing.
Products work just fine. Equalizers still has lots of sorries, mostly because I'm not willing to get my hands dirty and do things by brute force. All the remaining goals are just about manipulating is_ring_hom
. I wish most of them were solved by simp
.
There's also an instance where by subtype_instance
doesn't do what I hoped it would do. Perhaps @Simon Hudon would like to look at this?
Typical examples of the remaining goals are:
R S : examples.CommRing, f g : R ⟶ S ⊢ set.mem (add_monoid.zero ↥R) {r : ↥R | ⇑f r = ⇑g r}
(A subproblem here is to explain to me why this has set.mem
instead of \in
, and add_monoid.zero ↥R
instead of 0
! I'm really confused by both.)
If anyone wants to hack on this branch, please feel free.
I've just arrived at a conference I'm organising, and probably should stop working on lean for a while. :-)
I was going to say "you should post more precise coordinates about where this branch is" and then I remembered that you can click on the link in the title of the thread :D
the weird unfolding is probably because you have a universe metavariable
The equalizers file is at https://github.com/leanprover/mathlib/pull/422/files#diff-cc1aad82649d34fb81afe5403e9bd67f.
I've just pushed an attempt at products in Top
, that reduces it to two sorry
statements, which don't mention any category theory.
If you pull the limits-examples
branch of https://github.com/leanprover-community/mathlib/
, you'll find https://github.com/leanprover-community/mathlib/blob/limits-examples/category_theory/examples/topological_spaces/products.lean
The two remaining goals are just
β : Type u, f : β → Top, b : β ⊢ continuous (λ (g : Π (b : β), ↥(f b)), g b)
(here ↥(f b)
just means the underlying type of the Top
)
and
α : Type u, β : α → Type v, R : Π (a : α), topological_space (β a), γ : Type w, _inst_1 : topological_space γ, f : Π (a : α), γ → β a, Rh : ∀ (a : α), continuous (f a) ⊢ continuous (λ (x : γ) (b : α), f b x)
which I think needs no explaination, and is presumably meant to be proved by switching the arguments in continuous_pi
(which I discovered only because I tried to name this lemma continuous_pi
).
Duh, the second one is exactly continuous_pi
.
I am not sure what we are looking for, but I think that statement looks much nicer than the one with the fans
it's much more obvious what we need to prove
duh, and the first one is just continuous_apply
I agree, Mario. The problem was really @Patrick Massot typing tidy
a bit too soon. :-)
I just pushed this.
I'm surprised case on the fans is not done by the auto_cases stuff
No, it's not. auto_cases is pretty timid
if you're trying to construct a fan, tidy will use split and intro to get you most of the way there
(just in case anyone followed that link, I was a moment too fast, and you might want to reload it :-)
what does it mean that Top.pi_π
is @[simp]
? (Also that name is a bit confusing...)
Tagging it with @[simp] like that somehow(?!) encourages Lean to unfold its definition more freely later.
I don't understand that mechanism at all.
But I've found that you can often avoid stating lots of rfl
lemmas just by putting @[simp]
on the construction itself.
oh, that means it marks the equation lemmas as @[simp]
Sorry, voodoo-programming. :-)
because it's a def
Cool, okay, I'll say that's why, if asked in future. :-)
The first @[simp] was unnecessary, so I removed it.
I agree the name is bad. But I uniformly use π
and iota
for the maps in cones and cocones
and I think pi
is the correct name when talking about product types
so you end up with the name collision pi_π
for the maps out of product types ... :-(
why the dsimp
in the first construction and convert
in the second instead of directly applying the theorem?
@Mario Carneiro, if you have a chance, could you explain that "universe metavariable" comment from above?
I've fixed those; reload.
It's now the rings/equalizers.lean
file that I'm really unhappy about...
It's a weird bug that Kenny discovered. Here's a MWE:
instance sg {α} : semigroup α := sorry instance mm {α} : monoid α := { one := sorry, one_mul := sorry, mul_one := _, -- ∀ (a : α), semigroup.mul a sorry = a ..sg }
instance sg {α} : semigroup α := sorry instance mm {α : Type u} : monoid α := { one := sorry, one_mul := sorry, mul_one := _, -- ∀ (a : α), a * 1 = a ..sg }
If I could understand why set.mem
and add_monoid
have mysteriously appeared, I could ask Simon why subtype_instance
doesn't work. :-)
That is weird!
the presence of universe metavariables in the type of the theorem causes lean to unfold all sorts of stuff
indeed, changing CommRing
to CommRing.{v}
solves that problem
I agree, Mario. The problem was really Patrick Massot typing
tidy
a bit too soon. :-)
What happened is I copied the proof from Type and started to edit where things went wrong...
Thanks for your explanations Scott. I think it's unavoidable that notations needs to be learned in order to use the category theory goodies. But hopefully it will be much easier with more examples
There's also an instance where
by subtype_instance
doesn't do what I hoped it would do. Perhaps Simon Hudon would like to look at this?
This tactic is really specialized, it's meant to prove substuff is stuff, starting from the definition of substuff, assuming that definition obeys standard naming conventions. It never claimed to be able to prove any random subtype of some stuff is stuff.
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


You can add overlays to a baselayer, which will show a layer selector on the top right corner, defining layers like this.


Load facts into metadata store...
@if(oper=="init") {
The metadata store has @MetadataContext.playTotalTriples() triples.
}
@if(oper=="cancelled") {
Operation [Load Facts] has been cancelled.
Press OK button to return to HADataC's main page
Ok
}
Operation [Load Facts] complete -- check the results above to see if the clean was successful.
Press OK button to return to HADataC's main page
Ok
@if(oper=="loaded") {
}
Spreadsheet Templates:
Use the templates below to create metadata for your
scientific activities. A single spreadsheet may be used
to record needed metadata.
Alternatively, the three complementary spreadsheets listed below may be
used to record needed metadata. It is recommended that the these spreadsheets are used and populated
into HADataC following the order in the list below.
These are the Instructions on how to use the templates.
Spreadsheet Examples:
- Agent Spreadsheet
- Classes Spreadsheet
- Instances Spreadsheet


Amnesty International claims using Facebook and Google comes at 'a systemic cost'
NGO says the firm's data collection is 'an assault on privacy'
by Roland Moore-ColyerAMNESTY INTERNATIONAL has slammed Facebook and Google's data-centric business models, branding them as an "assault on privacy".
"Despite the real value of the services they provide, Google and Facebook's platforms come at a systemic cost," Amnesty said in its Surveillance Giants report. "The companies' surveillance-based business model forces people to make a Faustian bargain, whereby they are only able to enjoy their human rights online by submitting to a system predicated on human rights abuse.
"Firstly, an assault on the right to privacy on an unprecedented scale, and then a series of knock-on effects that pose a serious risk to a range of other rights, from freedom of expression and opinion, to freedom of thought and the right to non-discrimination."
Those are some strong words, but given the scrutiny both firms are currently under, it's not too surprising that the NGO would have such a stance.
But Amnesty is pulling no punches and noted how society is "trapped" into relying on services that monitor "every message and search query" or end up forgoing "the benefit of the digital world".
Its solution to this is to have more government regulation over how companies handle data. And big-picture wise, it would like to see the likes of Facebook and Google move away from such data-centric business models.
"The fact that the harvesting, analysis and monetisation of data is so core to their business model, has such a fundamental and widespread impact on the right to privacy, and is so inherently at odds with the enjoyment of this right, means that the companies should also be assessing whether their surveillance-based business model can ever be compatible with their responsibility to respect human rights," Amnesty said.
While we feel it's more likely that rainbow-farting unicorns will appear to stop Brexit, it's nice that Amnesty is worried about people's privacy. Saying that, folks share a Zuck-tonne of stuff online themselves, and we could picture a vast backlash if say Google started charging per search; imagine how many pub-based arguments would go unsolved.
Google has yet to respond to Amnesty's report, but Facebook's response was included in the report, and - surprise, surprise - it didn't agree with Amnesty's view.
"Your summary characterises Facebook's business model as 'surveillance-based."'We strongly disagree with this suggestion," Steve Satterfield, director of privacy and public policy at Facebook, retorted.
Satterfield noted that Facebook doesn't force anyone to use its service and thereby isn't reliant on surveillance. Further, he added that "data collection is not an end in itself for Facebook".
One might raise an eyebrow at that given Facebook's embroilment in the Cambridge Analytica data scandal last year, but the social network has spouted that it's changed since such issues came to light and is big into user privacy - as long as it's the opt-in kind.
Satterfield also turned the tables on Amnesty when it comes to facilitating human rights like freedom of speech.
"Like many other online companies, Facebook is supported through the sale of advertising. This enables billions of people around the world to connect and express themselves, on an unprecedented scale," he said, noting that the social network has helped "advance human rights" around the world by facilitating freedom of expression.
"Amnesty International itself has benefited from this ability to connect: The organisation has relied on Facebook ads and other Facebook products to reach supporters, raise money, and advance your mission."
To conclude Satterfield said that Facebook has mucked up in the past but it's trying to atone for its data sins: "We fully recognise that Facebook has made mistakes in the past, and are committed to continually improving our services and incorporating feedback from the people who use them. We would welcome the opportunity to engage further with you on your report and the important issues it raises."
Amnesty's report is yet another example of how big tech companies are getting ever more intense scrutiny into their data practices and being challenged left, right, and centre.
Holding such firms to account is important in our humble opinion. But then Facebook and Google have such vast influence, power and enough money to tip Iceland into the sea, so we're not entirely convinced they can be swayed to take onboard such criticism if they don't want to.
After all, Facebook pretty much shrugged off a £500,000 fine from the UK's Infomation Commissioner's Office, so some strong words from Amnesty aren't likely to rattle its cage much. µ
Further reading
Amnesty International reveals how 2FA is being bypassed automatically
- 20 Dec 2018
Amnesty International staff targeted by Israeli-made 'Pegasus' spyware
- 02 Aug 2018
Amnesty International rails against Skype and Snapchat over privacy
- 26 Oct 2016
ACLU and Amnesty appeal to Obama to pardon Edward Snowden
- 13 Sep 2016


---
layout: archive
title: Lean Prover Zulip Chat Archive
permalink: 113489newmembers/28257Cannotstarttutorialsnorimporttopologybasicnor.html
---
The archive URL format has changed. Please find this page at:
https://leanprover-community.github.io/archive/stream/113489-new-members/topic/Cannot.20start.20tutorials.2C.20nor.20import.20topology.2Ebasic.2C.20nor.2E.2E.2E.html


| Modifier and Type | Constant Field | Value |
|---|---|---|
public static final int |
COLUMNS_12WELL |
4 |
public static final int |
COLUMNS_1536WELL |
48 |
public static final int |
COLUMNS_24WELL |
6 |
public static final int |
COLUMNS_384WELL |
24 |
public static final int |
COLUMNS_48WELL |
8 |
public static final int |
COLUMNS_6WELL |
3 |
public static final int |
COLUMNS_96WELL |
12 |
public static final int |
PLATE_12WELL |
1 |
public static final int |
PLATE_1536WELL |
6 |
public static final int |
PLATE_24WELL |
2 |
public static final int |
PLATE_384WELL |
5 |
public static final int |
PLATE_48WELL |
3 |
public static final int |
PLATE_6WELL |
0 |
public static final int |
PLATE_96WELL |
4 |
public static final int |
PLATE_BIGDECIMAL |
2 |
public static final int |
PLATE_BIGINTEGER |
3 |
public static final int |
PLATE_DOUBLE |
0 |
public static final int |
PLATE_INTEGER |
1 |
public static final int |
ROWS_12WELL |
3 |
public static final int |
ROWS_1536WELL |
32 |
public static final int |
ROWS_24WELL |
4 |
public static final int |
ROWS_384WELL |
16 |
public static final int |
ROWS_48WELL |
6 |
public static final int |
ROWS_6WELL |
2 |
public static final int |
ROWS_96WELL |
8 |
| Modifier and Type | Constant Field | Value |
|---|---|---|
public static final int |
COLUMNS_12WELL |
4 |
public static final int |
COLUMNS_1536WELL |
48 |
public static final int |
COLUMNS_24WELL |
6 |
public static final int |
COLUMNS_384WELL |
24 |
public static final int |
COLUMNS_48WELL |
8 |
public static final int |
COLUMNS_6WELL |
3 |
public static final int |
COLUMNS_96WELL |
12 |
public static final int |
PLATE_12WELL |
1 |
public static final int |
PLATE_1536WELL |
6 |
public static final int |
PLATE_24WELL |
2 |
public static final int |
PLATE_384WELL |
5 |
public static final int |
PLATE_48WELL |
3 |
public static final int |
PLATE_6WELL |
0 |
public static final int |
PLATE_96WELL |
4 |
public static final int |
PLATE_BIGDECIMAL |
2 |
public static final int |
PLATE_BIGINTEGER |
3 |
public static final int |
PLATE_DOUBLE |
0 |
public static final int |
PLATE_INTEGER |
1 |
public static final int |
ROWS_12WELL |
3 |
public static final int |
ROWS_1536WELL |
32 |
public static final int |
ROWS_24WELL |
4 |
public static final int |
ROWS_384WELL |
16 |
public static final int |
ROWS_48WELL |
6 |
public static final int |
ROWS_6WELL |
2 |
public static final int |
ROWS_96WELL |
8 |
| Modifier and Type | Constant Field | Value |
|---|---|---|
public static final int |
COLUMNS_12WELL |
4 |
public static final int |
COLUMNS_1536WELL |
48 |
public static final int |
COLUMNS_24WELL |
6 |
public static final int |
COLUMNS_384WELL |
24 |
public static final int |
COLUMNS_48WELL |
8 |
public static final int |
COLUMNS_6WELL |
3 |
public static final int |
COLUMNS_96WELL |
12 |
public static final int |
PLATE_12WELL |
1 |
public static final int |
PLATE_1536WELL |
6 |
public static final int |
PLATE_24WELL |
2 |
public static final int |
PLATE_384WELL |
5 |
public static final int |
PLATE_48WELL |
3 |
public static final int |
PLATE_6WELL |
0 |
public static final int |
PLATE_96WELL |
4 |
public static final int |
PLATE_BIGDECIMAL |
2 |
public static final int |
PLATE_BIGINTEGER |
3 |
public static final int |
PLATE_DOUBLE |
0 |
public static final int |
PLATE_INTEGER |
1 |
public static final int |
ROWS_12WELL |
3 |
public static final int |
ROWS_1536WELL |
32 |
public static final int |
ROWS_24WELL |
4 |
public static final int |
ROWS_384WELL |
16 |
public static final int |
ROWS_48WELL |
6 |
public static final int |
ROWS_6WELL |
2 |
public static final int |
ROWS_96WELL |
8 |
| Modifier and Type | Constant Field | Value |
|---|---|---|
public static final int |
COLUMNS_12WELL |
4 |
public static final int |
COLUMNS_1536WELL |
48 |
public static final int |
COLUMNS_24WELL |
6 |
public static final int |
COLUMNS_384WELL |
24 |
public static final int |
COLUMNS_48WELL |
8 |
public static final int |
COLUMNS_6WELL |
3 |
public static final int |
COLUMNS_96WELL |
12 |
public static final int |
PLATE_12WELL |
1 |
public static final int |
PLATE_1536WELL |
6 |
public static final int |
PLATE_24WELL |
2 |
public static final int |
PLATE_384WELL |
5 |
public static final int |
PLATE_48WELL |
3 |
public static final int |
PLATE_6WELL |
0 |
public static final int |
PLATE_96WELL |
4 |
public static final int |
PLATE_BIGDECIMAL |
2 |
public static final int |
PLATE_BIGINTEGER |
3 |
public static final int |
PLATE_DOUBLE |
0 |
public static final int |
PLATE_INTEGER |
1 |
public static final int |
ROWS_12WELL |
3 |
public static final int |
ROWS_1536WELL |
32 |
public static final int |
ROWS_24WELL |
4 |
public static final int |
ROWS_384WELL |
16 |
public static final int |
ROWS_48WELL |
6 |
public static final int |
ROWS_6WELL |
2 |
public static final int |
ROWS_96WELL |
8 |
| Modifier and Type | Constant Field | Value |
|---|---|---|
public static final int |
COLUMNS_12WELL |
4 |
public static final int |
COLUMNS_1536WELL |
48 |
public static final int |
COLUMNS_24WELL |
6 |
public static final int |
COLUMNS_384WELL |
24 |
public static final int |
COLUMNS_48WELL |
8 |
public static final int |
COLUMNS_6WELL |
3 |
public static final int |
COLUMNS_96WELL |
12 |
public static final int |
PLATE_12WELL |
1 |
public static final int |
PLATE_1536WELL |
6 |
public static final int |
PLATE_24WELL |
2 |
public static final int |
PLATE_384WELL |
5 |
public static final int |
PLATE_48WELL |
3 |
public static final int |
PLATE_6WELL |
0 |
public static final int |
PLATE_96WELL |
4 |
public static final int |
PLATE_BIGDECIMAL |
2 |
public static final int |
PLATE_BIGINTEGER |
3 |
public static final int |
PLATE_DOUBLE |
0 |
public static final int |
PLATE_INTEGER |
1 |
public static final int |
ROWS_12WELL |
3 |
public static final int |
ROWS_1536WELL |
32 |
public static final int |
ROWS_24WELL |
4 |
public static final int |
ROWS_384WELL |
16 |
public static final int |
ROWS_48WELL |
6 |
public static final int |
ROWS_6WELL |
2 |
public static final int |
ROWS_96WELL |
8 |
| Modifier and Type | Constant Field | Value |
|---|---|---|
public static final int |
COLUMNS_12WELL |
4 |
public static final int |
COLUMNS_1536WELL |
48 |
public static final int |
COLUMNS_24WELL |
6 |
public static final int |
COLUMNS_384WELL |
24 |
public static final int |
COLUMNS_48WELL |
8 |
public static final int |
COLUMNS_6WELL |
3 |
public static final int |
COLUMNS_96WELL |
12 |
public static final int |
PLATE_12WELL |
1 |
public static final int |
PLATE_1536WELL |
6 |
public static final int |
PLATE_24WELL |
2 |
public static final int |
PLATE_384WELL |
5 |
public static final int |
PLATE_48WELL |
3 |
public static final int |
PLATE_6WELL |
0 |
public static final int |
PLATE_96WELL |
4 |
public static final int |
PLATE_BIGDECIMAL |
2 |
public static final int |
PLATE_BIGINTEGER |
3 |
public static final int |
PLATE_DOUBLE |
0 |
public static final int |
PLATE_INTEGER |
1 |
public static final int |
ROWS_12WELL |
3 |
public static final int |
ROWS_1536WELL |
32 |
public static final int |
ROWS_24WELL |
4 |
public static final int |
ROWS_384WELL |
16 |
public static final int |
ROWS_48WELL |
6 |
public static final int |
ROWS_6WELL |
2 |
public static final int |
ROWS_96WELL |
8 |
| Modifier and Type | Constant Field | Value |
|---|---|---|
public static final int |
COLUMNS_12WELL |
4 |
public static final int |
COLUMNS_1536WELL |
48 |
public static final int |
COLUMNS_24WELL |
6 |
public static final int |
COLUMNS_384WELL |
24 |
public static final int |
COLUMNS_48WELL |
8 |
public static final int |
COLUMNS_6WELL |
3 |
public static final int |
COLUMNS_96WELL |
12 |
public static final int |
PLATE_12WELL |
1 |
public static final int |
PLATE_1536WELL |
6 |
public static final int |
PLATE_24WELL |
2 |
public static final int |
PLATE_384WELL |
5 |
public static final int |
PLATE_48WELL |
3 |
public static final int |
PLATE_6WELL |
0 |
public static final int |
PLATE_96WELL |
4 |
public static final int |
PLATE_BIGDECIMAL |
2 |
public static final int |
PLATE_BIGINTEGER |
3 |
public static final int |
PLATE_DOUBLE |
0 |
public static final int |
PLATE_INTEGER |
1 |
public static final int |
ROWS_12WELL |
3 |
public static final int |
ROWS_1536WELL |
32 |
public static final int |
ROWS_24WELL |
4 |
public static final int |
ROWS_384WELL |
16 |
public static final int |
ROWS_48WELL |
6 |
public static final int |
ROWS_6WELL |
2 |
public static final int |
ROWS_96WELL |
8 |
| Modifier and Type | Constant Field | Value |
|---|---|---|
public static final int |
COLUMNS_12WELL |
4 |
public static final int |
COLUMNS_1536WELL |
48 |
public static final int |
COLUMNS_24WELL |
6 |
public static final int |
COLUMNS_384WELL |
24 |
public static final int |
COLUMNS_48WELL |
8 |
public static final int |
COLUMNS_6WELL |
3 |
public static final int |
COLUMNS_96WELL |
12 |
public static final int |
PLATE_12WELL |
1 |
public static final int |
PLATE_1536WELL |
6 |
public static final int |
PLATE_24WELL |
2 |
public static final int |
PLATE_384WELL |
5 |
public static final int |
PLATE_48WELL |
3 |
public static final int |
PLATE_6WELL |
0 |
public static final int |
PLATE_96WELL |
4 |
public static final int |
PLATE_BIGDECIMAL |
2 |
public static final int |
PLATE_BIGINTEGER |
3 |
public static final int |
PLATE_DOUBLE |
0 |
public static final int |
PLATE_INTEGER |
1 |
public static final int |
ROWS_12WELL |
3 |
public static final int |
ROWS_1536WELL |
32 |
public static final int |
ROWS_24WELL |
4 |
public static final int |
ROWS_384WELL |
16 |
public static final int |
ROWS_48WELL |
6 |
public static final int |
ROWS_6WELL |
2 |
public static final int |
ROWS_96WELL |
8 |
| Modifier and Type | Constant Field | Value |
|---|---|---|
public static final int |
BIGDECIMAL |
2 |
public static final int |
BIGINTEGER |
3 |
public static final int |
DOUBLE |
0 |
public static final int |
INTEGER |
1 |
| Modifier and Type | Constant Field | Value |
|---|---|---|
public final int |
BIGDECIMAL |
2 |
public final int |
BIGINTEGER |
3 |
public final int |
DOUBLE |
0 |
public final int |
INTEGER |
1 |
Copyright © 2017. All rights reserved.


Mode: Normal
| Row Title01 | Row Title02 | Row Title03 | Row Title04 | Row Title05 | Row Title06 | Row Title07 | Row Title08 | Row Title09 | Row Title10 | |
|---|---|---|---|---|---|---|---|---|---|---|
| Col Title01 | detail Text detail Text detail Text detail Text detail Text | detail Text detail Text detail Text | detail Text | detail Text detail Text detail Text | detail Text | detail Text | detail Text | detail Text detail Text detail Text | detail Text | detail Text detail Text detail Text |
| Col Title02 | detail Text detail Text detail Text | detail Text detail Text detail Text detail Text detail Text detail Text | detail Text detail Text | detail Text detail Text detail Text detail Text | detail Text detail Text detail Text detail Text detail Text detail Text detail Text detail Text | detail Text detail Text | detail Text detail Text detail Text detail Text | detail Text detail Text | detail Text detail Text | detail Text detail Text |
| Col Title03 | detail Text detail Text | detail Text detail Text | detail Text detail Text | detail Text detail Text | detail Text detail Text | detail Text detail Text | detail Text detail Text | detail Text detail Text | detail Text detail Text | detail Text detail Text |
| Col Title04 | detail Text detail Text detail Text detail Text | detail Text detail Text detail Text detail Text | detail Text detail Text detail Text detail Text | detail Text detail Text detail Text detail Text | detail Text detail Text detail Text detail Text | detail Text detail Text detail Text detail Text | detail Text detail Text detail Text detail Text | detail Text detail Text detail Text detail Text | detail Text detail Text detail Text detail Text | detail Text detail Text detail Text detail Text |
| Col Title05 | detail Text detail Text detail Text detail Text | detail Text detail Text detail Text detail Text | detail Text detail Text detail Text detail Text | detail Text detail Text detail Text detail Text | detail Text detail Text detail Text detail Text | detail Text detail Text detail Text detail Text | detail Text detail Text detail Text detail Text | detail Text detail Text detail Text detail Text | detail Text detail Text detail Text detail Text | detail Text detail Text detail Text detail Text |
| Col Title06 | detail Text detail Text | detail Text detail Text | detail Text detail Text | detail Text detail Text | detail Text detail Text | detail Text detail Text | detail Text detail Text | detail Text detail Text | detail Text detail Text | detail Text detail Text |
| Col Title07 | detail Text detail Text detail Text detail Text detail Text | detail Text detail Text detail Text | detail Text | detail Text detail Text detail Text | detail Text | detail Text | detail Text | detail Text detail Text detail Text | detail Text | detail Text detail Text detail Text |
| Col Title08 | detail Text detail Text detail Text | detail Text detail Text detail Text detail Text detail Text detail Text | detail Text detail Text | detail Text detail Text detail Text detail Text | detail Text detail Text detail Text detail Text detail Text detail Text detail Text detail Text | detail Text detail Text | detail Text detail Text detail Text detail Text | detail Text detail Text | detail Text detail Text | detail Text detail Text |
| Col Title09 | detail Text detail Text | detail Text detail Text | detail Text detail Text | detail Text detail Text | detail Text detail Text | detail Text detail Text | detail Text detail Text | detail Text detail Text | detail Text detail Text | detail Text detail Text |
| Col Title10 | detail Text detail Text detail Text detail Text | detail Text detail Text detail Text detail Text | detail Text detail Text detail Text detail Text | detail Text detail Text detail Text detail Text | detail Text detail Text detail Text detail Text | detail Text detail Text detail Text detail Text | detail Text detail Text detail Text detail Text | detail Text detail Text detail Text detail Text | detail Text detail Text detail Text detail Text | detail Text detail Text detail Text detail Text |
| Col Title11 | detail Text detail Text detail Text detail Text detail Text | detail Text detail Text detail Text | detail Text | detail Text detail Text detail Text | detail Text | detail Text | detail Text | detail Text detail Text detail Text | detail Text | detail Text detail Text detail Text |
| Col Title12 | detail Text detail Text | detail Text detail Text | detail Text detail Text | detail Text detail Text | detail Text detail Text | detail Text detail Text | detail Text detail Text | detail Text detail Text | detail Text detail Text | detail Text detail Text |


--- layout: page title: Post categories - Archive description: Blog categories for this website. ---
— {{ post.description }} Read more


We combine creativity with fresh and modern content to engage your audience.
Sproutmedia is a Wellington-based company that believes high quality and affordability should go hand-in-hand. We offer more than a decade of experience working with companies of all sizes. We provide a complete range of corporate video production services – from scripting, filming and post production, right through to delivery with a digital marketing support package. Whatever your needs – an effective promotional video for web, an inspiring recruitment advert or a series of internal corporate communication videos – get in touch with us today to discuss your own corporate video production requirements.
We’ve created engaging solutions for a myriad of business challenges. For Corporate and Promotional Video Production, SPROUTMEDIA combines creativity with fresh and modern content to engage your audience.


Collegiate Internationals is an initiative of 'Collegiate Congress'. Officiated by international students, we aimed to bring all international students together, form a community, and help them in all aspects of their college careers. Collegiate Internationals organizes events which allow the students to share their ideas & culture, create bonds and build a professional network.


Here is some text to broach the subject of my field relevant experience. This text should probably run for at leas three or four line without being verbose. Try talking about managment skills without looking overconfident.
Here is some text to broach the subject of what I am seeking in a career. This text should probably run for at leas three or four line without being verbose. Try talking about your desire to be creative and flexible without looking like a dreamer with no work ethic.
Here is some text to broach the subject of what I am seeking in a career. This text should probably run for at leas three or four line without being verbose. Try talking about your desire to be creative and flexible without looking like a dreamer with no work ethic.
Professional seeking full time work in a demanding and engaging field
This is where I talk about myself and all of my hobbies. I can style this section to let others know that it is a less professional setting, I can provide links to some of my favorite sites in the section as well. then after the links I will provide yet more words to describe myself. It sounds fun because it is.


bibliotek-o is an ontology framework for modeling bibliographic metadata. It includes:
This site hosts the bibliotek-o ontology. The current version of the ontology (Version 1.1.0) is available in HTML and RDF/XML OWL via content negotiation from http://bibliotek-o.org/ontology/ (HTML) and http://bibliotek-o.org/ontology.owl (OWL). The previous version of the ontology (Version 1.0.1) is available from http://bibliotek-o.org/1.0/ontology/ (HTML) and http://bibliotek-o.org/1.0/ontology.owl (OWL).
Additional resources:
bibliotek-o is a joint product of the Linked Data for Libraries (LD4L) Labs and Linked Data for Production (LD4P) projects.
This work in provided under a CC0 waiver, it is published from the United States.


public class Splitter
extends java.lang.Object
| Constructor and Description |
|---|
Splitter(Instances inst)
initializes the splitting
|
Splitter(Instances inst,
int folds)
initializes the splitting
|
Splitter(Instances inst,
int folds,
boolean invert)
initializes the splitting
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
getInvertSplitFolds()
Gets whether to use the first fold as training set (= FALSE) or as
test set (= TRUE)
|
int |
getSplitFolds()
Gets the split percentage for splitting train set into train and test set
|
Instances |
getTestset()
returns the test set
|
Instances |
getTrainset()
returns the training set
|
boolean |
getVerbose()
Gets the verbose state
|
static void |
main(java.lang.String[] args)
For testing only.
|
void |
setInvertSplitFolds(boolean invertSplitFolds)
Sets whether to use the first fold as training set (= FALSE) or as
test set (= TRUE).
|
void |
setSplitFolds(int splitFolds)
Set the percentage for splitting the train set into train and test set.
|
void |
setVerbose(boolean verbose)
Set the verbose state.
|
public Splitter(Instances inst)
inst
- the instances to split into train and testpublic Splitter(Instances inst, int folds)
inst
- the instances to split into train and testfolds
- the number of folds to use for splittingpublic Splitter(Instances inst, int folds, boolean invert)
inst
- the instances to split into train and testfolds
- the number of folds to use for splittinginvert
- whether to invert the foldspublic void setSplitFolds(int splitFolds)
splitFolds
- the split percentage (1/splitFolds*100)public int getSplitFolds()
public void setInvertSplitFolds(boolean invertSplitFolds)
invertSplitFolds
- whether to invert the folding schemepublic boolean getInvertSplitFolds()
public void setVerbose(boolean verbose)
verbose
- the verbose statepublic boolean getVerbose()
public Instances getTrainset() throws java.lang.Exception
java.lang.Exception
- if something goes wrongpublic Instances getTestset() throws java.lang.Exception
java.lang.Exception
- if something goes wrongpublic static void main(java.lang.String[] args) throws java.lang.Exception
args
- the commandline argumentsjava.lang.Exception
- if something goes wrong, e.g., file not found


Files CCore/inc/ObjHost.h CCore/src/ObjHost.cpp
ObjHost can host a set of objects. Each object is identified by its name.
ObjBase is a base class of an object to be hosted.
class ObjBase : public NoCopyBase<MemBase,InterfaceHost>
{
....
public:
ObjBase();
explicit ObjBase(TextLabel name);
virtual ~ObjBase();
void wait_released();
bool wait_released(MSec timeout);
bool wait_released(TimeScope time_scope);
};
This class is polymorphic. It has a virtual destructor, so you can destroy an object of derived type using a pointer to the base class. It is derived from MemBase_nocopy, so it is non-copyable and inherits memory allocation operators, based on CCore heap. This class is also derived from the InterfaceHost.
You may specify a TextLabel in the constructor to name the internal anti-semaphore.
wait_release() methods wait until the object gets out of use. You should use these methods after you detach the object from the host, in case if you manage an object not using one of the ObjMaster class.
ObjHost is a hosting class. There is a default global object of this type.
class ObjHost : NoCopy
{
....
public:
explicit ObjHost(TextLabel name);
~ObjHost();
void add(ObjBase &obj,StrLen name);
void del(ObjBase &obj);
static ObjHost & Default();
template <ObjInfoType Info> class List;
};
Constructor uses the name to name the internal mutex.
add() attaches the given object with the given name. When it is done, the object can be "hooked" using the class ObjHook.
del() detaches the object. After it is finished, the object is no more visible, but may still be in use. Use the wait_release() method of the object to block execution while the object is used and cannot be safely destroyed.
Default() returns a reference to the default host object.
ObjHook "hooks" an object, attached to the host.
class ObjHook : NoCopy
{
....
public:
//
// assign/move/swap are not provided to prevent cyclic dependencies
//
// constructors
ObjHook(ObjHost &host,StrLen name);
explicit ObjHook(StrLen name);
ObjHook(JustTryType,ObjHost &host,StrLen name);
ObjHook(JustTryType,StrLen name);
~ObjHook();
// cast
bool operator + () const;
bool operator ! () const;
void requestInterface(InterfaceCaster &caster) { if( obj ) obj->requestInterface(caster); }
template <class T>
T * cast() const;
template <class T>
T * cast_guarded() const;
template <class T>
operator T * () const { return cast_guarded<T>(); }
// copy objects
ObjHook(const ObjHook &hook);
};
Constructor hooks an object with the given name at the given host, or default host. Try-variants do not throw exceptions if the object is not found, they create a null hook.
Destructor releases the object.
operator + and operator ! can be used to check, if the hook is null.
requestInterface() forwards the interface request to the hooked object, if any.
cast() calls the pickInterface() of the object to acquire a desired interface.
cast_guarder() is a guarded variant of the cast(), if the result if null, an exception is thrown.
Copy constructor creates a copy of the hook, it points to the same object.
ObjMaster can be used to attach and detach an object to a host.
class ObjMaster : NoCopy
{
....
public:
ObjMaster(ObjHost &host,ObjBase &obj,StrLen name);
ObjMaster(ObjBase &obj,StrLen name);
~ObjMaster();
};
Constructor does attach. If the host is not specified, the default host is used. The object is attached with the given name. An exception is thrown in case of error.
Destructor does detach and waits until the object gets out of use. After the destructor is finished, it is safe to destroy the object.
This class is similar to the ObjMaster. The difference is: the object is given by a pointer, not by a reference, and destructor deletes the object. So the object must be constructed using the operator new.
class ObjMaster_delete : NoCopy
{
....
public:
ObjMaster_delete(ObjHost &host,ObjBase *obj,StrLen name);
ObjMaster_delete(ObjBase *obj,StrLen name);
~ObjMaster_delete();
};
This class can be used to build a list of records with information about objects, attached to a host.
template <ObjInfoType Info>
class ObjHost::List : NoCopy
{
....
public:
List();
~List();
void build(ObjHost &host=Default());
const Info * getPtr() const;
const Info * getPtr_const() const;
ulen getLen() const;
};
Constructor creates an empty object.
build() appends the list with Info records about objects, attached to the given host. If the record contains a pointer to the object, the object is hooked and released later by the destructor of the list. Objects may be selected based on they properties to be included in the list.
The range access is provided to the record range.
There are four type of Info records.
This info record contains only the name of object.
struct ObjInfo
{
....
// data
StrLen name;
// print object
void print(PrinterType &out) const;
};
print() prints the name.
This info record contains the name of object and the pointer to the object.
struct ObjInfo_obj
{
....
// data
StrLen name;
ObjBase *obj;
// methods
ObjBase * getObj() const { return obj; }
// print object
void print(PrinterType &out) const;
};
print() prints the name.
This info record contains the name of the object and selects only objects, implementing the given interface.
template <UnidType T>
struct ObjInfo_if
{
....
// data
StrLen name;
// print object
void print(PrinterType &out) const;
};
print() prints the name.
This info record contains the name of object and the pointer to the object and selects only objects, implementing the given interface.
template <UnidType T>
struct ObjInfo_obj_if
{
....
// data
StrLen name;
Extra extra;
// methods
ObjBase * getObj() const { return extra.obj; }
T * getPtr() const { return extra.ptr; }
// print object
void print(PrinterType &out) const;
};
print() prints the name.


this is h3
inside firstdiv
inside 2iv
id must be unique
this is a list
confirm:
feedback
pieriandata
facebook