Boca Bearings All Star Companies Interview: Robot Band Builders

1. How did you come up with the team name “TeamDARE Eindhoven”?
Our team is called “TeamDARE” which stands for “Daring Autonomous Robots Eindhoven”. We needed a team name when participating in Eurobot in 2005. The name sticked since then.

2. Please give your name and any professional designation and tell me what each of your engineering specialties are and where and how did you each gain them?
TeamDARE consists of 9 experts from various high tech companies and institutes in Eindhoven or her direct vicinity, including ASML, Philips, Prodrive, CCM, DAF Trucks, The Mathworks, and the University of Technology Eindhoven. The expertise that each brings in for the team comes from our jobs at these companies. Although, it also works the other way around. The practical knowledge from TeamDARE is also applicable in our daily work in the high tech industry.

3. What is the TU/e?
It is the (Dutch) abbreviation of the University of Technology Eindhoven (Technische Universiteit/eindhoven). Two of our members work at the mechanics department of this university. One as the project manager for robotics, the other as a student. All of the team members studied at this university.

4. How did you participate in Eurobot?
Back in 2001, some of the current members of TeamDARE participated in the Eurobot competition as an internship at the TU/e. It was organized by three of its departments: Electrical engineering, Mechanical engineering and Computer Science. Combining these disciplines turned out to be really fun and successful (we finished 2nd).

The second and third time that we participated -in 2005 and 2006- we participated as an independent team and were financially supported mainly by the TU/e, Philips and ASML.

5. What is your industry experience in embedded, intelligent systems? What kinds of systems?
In their daily lives, the members of TeamDARE, work on complex embedded systems such as, for example, the wafer steppers from ASML, MRI scanners from Philips. These systems require high quality standards for mechatronics and software. Also robustness follows from our daily work; a nice example of this is are the high robustness requirements that are required in DAF trucks. They have many moving parts, that always have to work in challenging environment conditions.

Applying such ways of working in our robot project is essential to also make sure the music robots always work straight out of their box, even when set up in stress conditions, i.e. on a dark, loud, and often small podium.

Specifically the expertise we apply comes from the team members working at:

6. Briefly describe some other robots you built with their names.
Before starting the work on the robot band, we participated at Eurobot three times. For this competition a team typically builds two (or back in 2001 multiple) robots that have to complete a task autonomously in 90 seconds against an opponent. The goal of the game is changed each year to make it more easy for “new comers” to come up with a competitive robot. The required autonomy and time limit guarantee that the smartest team has most change of winning.

As mentioned before, we participated at Eurobot in 2001 as an internship at the TU/e. We then built 11 robots that all solved a small part of the problem (in that year, placing flags on cylinders with different height and mobility). Our swarm of robots yielded a 2nd place and the concept was so successful that next year the rules were changed, limiting the number of robots each team could construct.

After this competition, the core members entered the Dutch version of the Robotwars competition with a robot named Cyclone. This was a huge moving cylinder that had a spinning outer shell. This was great fun to built, but not very high tech, as these robots from a technical point of view are not much more complex than a radio controlled car.

So we sent back to Eurobot and participated two more times. Reaching the quarter finals in 2005, and finishing again second in 2006. We stopped participating after three times in search for something completely different.

We then found the Artemis Orchestra Contest in 2008. The contest dictated to make a robot that can play an instrument of choice, without alterning the instrument itself and as part of an orchestra. We decided to compete by building a robot that can play an acoustic guitar. It was built in about four months and we got really enthusiastic responses wherever we played. This was the motivation for us to continue to expand the band, irrespective of the contest (which stopped after 2009).

7. Who were your sponsors for the robot band project? Can you provide links to their websites?
see: http://www.teamdare.nl/ it has a list of our sponsors with links. We have several different types of sponsors. Some provide us the parts we need for construction, a few help out financially, others such as e.g. BocaBearings help with publicity.

8. How did you adhere to simplicity and low cost with the robot band?
Simplicity is not our goal on itself, but more a requirement to end up with a robust solution. As a simple example: a complex system depending on a 100 small components in a cascade, each with 99% robustness, will fail about 63% of the time. Complex systems also take much longer to test and debug.

In order to implement things as simple as possible, we have long discussions at the beginning of each project, trying to see if a certain part of the problem is best solved in software, or using electronics or with a mechanical solution. A typical example is the accurate positioning of an arm. Often accuracy can be increased using all three disciplines and really depend on the specific use case which is yield the simplest result.

Also low cost is not a goal on itself, but a consequence when depending on sponsors and your own budget.

9. Please discuss the circuit design and layout for the robot band.
Each music robot is roughly designed similarly, from a high level circuit design point of view, consisting of three layers: actuation, scheduling and control.

Actuation is the lowest layer. We use microcontrollers (AVR32 family from Atmel) to control motors, and handle sensor information. On this level the controllers have no knowledge of music and only handle simple actuation commands instantly, e.g. move a motor from A to B with a given profile. The intermediate layer does teh scheduling of actuations and also runs on microcontrollers (low-end 8-bit RISC controllers). These controllers receive a lists of music notes for a certain instrument, including how and when each should be played, e.g. exact timing and volume. These lists of notes are translated to commands that can be executed by the low level layer. Each command is sent at their corresponding time. At the highest level, songs are controlled. Each song is decomposed into instruments and for each instrument the song is converted in lists of notes that can be sent to the scheduling controllers. The highest layer is no longer time critical, i.e. can be non-real time and is therefore easily implemented on a PC. This is important to also be able to add a user interface. This layering is important for two reasons. First, to be able to have precise control and actuation, together with a easy user interface that can start, stop, and add songs. Second, to be able to extent the band to an arbitrary number of instruments.

All circuit boards, are designed by ourselves. Some have even been etched by us.

10. Please discuss the design and mechanical and robotic construction of the robot band.
With respect to mechanics, there has been a steady increase in complexity for each new robot that has been constructed. The guitar is the most simple of the three. It consists of six plectra on little arms that each actuate one string. The arms are rotated with a servo motor. The “left hand” of the guitar player consists of a grid of pneumatic pistons that press down the string at the correct fret position. The volume of each note is controlled by setting a second servo motor that controls the height of the a plectrum with respect to its string.

The drums conceptually seem simple: one stick for each tom, controlled by a servo motor. But in order to get the timing, volume and the bounce of these sticks correct a very complex motion controller was required. Furthermore, the pedal for the hi-hat and the muting of the crash cymbal was implemented using pneumatics.

The pan flute robot is the most complex robot of the three in terms of mechanics. Instead of “just” having a nozzle for each tube, we wanted to use a single pipe and rotate the pan flute back and forth. In order to get the correct tone out of each tube, the nozzle needed to be controlled over three degrees of freedom: horizontally, vertically and one axis of rotation. In addition, the airflow influences the pitch of the sound. To make things really complex, on each tube of the pan flute a semitone can be produced in addition to a note. For this, a tube needs to be partially obstructed. We implemented this using a small rubber cushion that mimics lips and a second air flow supply.

11. Please discuss the software design for the robot band. What programming languages and software did you use?
The whole band currently runs on 8 microcontrollers and two PCs, due to the layered design, mentioned before. Most of the code on the microcontrollers is written in C, with the exception of some small critical parts that are implemented in assembly. The PC software is mostly written in C++. For some nice 3D visualization on a big screen, we have written a player in C++ and GPU code, this runs on the second PC.

In addition, a lot of software has been written to automate the “song writing”, mostly in C and C++. Basically, these tools convert midis to a format suitable for our robots and can simulate how a song will sound when played on the robots.

12. What instruments are included in the robot band?
As mentioned before, the band consists of a guitar, drum set and pan flute. But conceptually, the 3D visualization can be seen as a fourth instrument. Instead of making sound, however, it shows a 3D rendering of the music that is played. We are currently working on a double bass playing robot and have future plans for the saxophone and piano.

13. How did the robot band overcome the instrumental performance capabilities that you lacked?
With science! Playing music in its basic form is about correctly producing notes on instruments. It all depends on the definition of “correctly” to what level of naturalness the robots can play music. Not being able to compose songs ourselves, we depend on the information that can be found in digital tablature, such as midi. These formats typically contain accurate time and volume information for each note, and depending on the instrument type, also effects like changes in pitch and duration.

When the robots reconstruct this digital tablature they play music. Unfortunately, musicians deviate from the written music in all kind of ways when they put a certain emotion in a song. We have not found any means yet to also include these. We are still searching for a scientific description of emotions in music. Who knows this might give our music robots some soul.


Role of private sector in health care - contracting, Biology

Role of Private Sector in Health Care - Contracting

The government can transfer some of its work to the private sector by contracting. If the cost of resultant services (including the government’s cost in administering and monitoring the contract) are lower than the cost of services extended by the government directly, then contracting can be a viable option. Some funds will then become available for other uses.

Contracting can also free up scarce skilled government personnel who can devote their time to other managerial tasks which only the government can do. Such arrangements will also produce additional benefits beyond the considerations of cost and savings. It would promote the establishment of an environment in which there is a separate private market for health care infrastructure including manufacturers and distributors. By having contract clauses that ensure efficient delivery, contracting can influence healthy private market practices and prices.

Posted Date: 12/15/2012 6:30:47 AM | Location : United States

Related Discussions:- Role of private sector in health care - contracting, Assignment Help, Ask Question on Role of private sector in health care - contracting, Get Answer, Expert's Help, Role of private sector in health care - contracting Discussions

Write discussion on Role of private sector in health care - contracting
Your posts are moderated
Related Questions
Q. Nematode identity card. How are nematodes characterized according to examples of representing beings, type of symmetry basic morphology, , germ layers and coelom, digestive syst

Q. What are the hormones secreted by the neurohypophysis? What are their respective functions? The neurohypophysis secretes the antidiuretic hormone (ADH) and oxytocin. Oxytoci

what is the process of nitrogen fixation in soil by bacteria

What is the endocrine function of the placenta? The placenta is not a permanent gland of the endocrine system but it also has endocrinal function. The placenta produces estroge

Q. Explain Hypertensive Response? Hypertension at rest has long been known to be a risk factor for the development of coronary artery disease (CAD). Significant elevation of B

Why Fish and Sea Foods are important for human Body? They are rich sources of proteins (20-25%) of a high biological value. Dry fishes contain more (60%) proteins since most of

Animals of the open water zone The limnetic region of this zone contains certain fishes as well as rotifers, zooplankton such as crustacean and protozoan. In the profundal zo


Oct 24, 2014

Tourist get mauled by tiger in Phuket's Tiger Kingdom

Paul Goldie -pic credit to phuketwan.com

My son touching a tiger...

“We did everything as the park people advised,” Goudie told reporters .
“I am not sure why it bit me,” he said.
He punched the tiger as it attacked him.
“When it did [attack] I had no choice except to whack it in the face a couple of times,” he said.
Tiger Kingdom opened in Phuket in August 2013 and draws hundreds of tourist per day. The park allows them to enter several different tiger enclosures, posing for photographs with the chained and sedated adult  tigers - sometimes even sitting on their backs - and feeding bottles to cubs.
dress codes warning at Tiger Temple Kanchanaburi

Before entering the pens, guests are required to remove all loose belongings, including shoes, wash their hands and sign a waiver absolving Tiger Kingdom of any responsibility in the event of an accident.
Tiger and other animal parks in Thailand have been drawing increasing amounts of criticism, not only due to treatment of the animals that activists and many tourists say is cruel, but because the wild animals, despite their sedation, occasionally still resort to their natural instincts.
A 19-year-old British tourists was left with permanent scarring at Tiger Temple park in the Kanchanaburi last year when a fully-grown tiger knocked her down and bit her leg.
In 2011, a Thai woman suffered severe head and arm injuries after being mauled at the Million Years Stone Park in Pattaya.
Yours truly has been to the Tiger Temple in Kanchanaburi  and well, it is a fascinating experience to touch and stroke a tiger, but we have to still understand that they are wild animals and so we should not do anything to startle them or even deem us a threat though it can be hard at times with visitors all around and some of them thinking they can do anything they like because they paid for the privilege.

As for cruelty, I am of a mixed opinion here as there are two ways of looking at it . One is, the animals are well fed and safe despite probably some rough handling by some handlers if the tigers are in the wild, our world is no longer like the world years before where wild animals can roam safely in huge rain forest etc.

Instead, rainforests are being cut down and their natural habitat no longer exists and they are a threat to humans as well and at threat from illegal poachers as well.

This is my 2 cents. But naturally I do not like seeing the animals being roughly handled or abused. I believe there has to be respect all around.. between humans, humans and animals and so on.

What do you think of my blog???


Looking for the latest version? Download agena-2.9.8-src.tar.gz (7.0 MB)
Name Modified Size Downloads / Week Status
Totals: 5 Items   195.4 kB 4
Manuals 2016-08-15 1111 weekly downloads
Sources 2016-08-14 77 weekly downloads
Binaries 2016-08-14 1111 weekly downloads
Packages 2016-01-02 11 weekly downloads
README.TXT 2016-08-15 195.4 kB 44 weekly downloads
agena >> `The Power of Procedural Programming` What are the Changes ? ---------------------- 2.9.8, August 14, 2016 New features: - The new `|` operator compares two numbers a, b, and returns -1 if a < b, 0 if a = b, and 1 if a > b. It is twice than fast as the `sign` operator. - The new `|-` operator computes the absolute difference of two numbers x and y, i.e. abs(x - y). - The new `identity` function just returns all its arguments. - The new function `strings.compare` compares two strings and returns the first position where they differ, or 0 if both strings are equal. If called with any option, the function returns the result of the C function strcmp. - The new `astro.cweek` function returns the calendar week of the given date, a number in the range 1 to 53, according to the ISO 8601 standard. - The new function `astro.lastcweek` determines the last week of a year. - The new function `astro.cweekmonsun` computes the Gregorian dates of the Monday and Sunday for a given calendar week. - The new function `os.esd` computes the Excel Serial Date. - The new function `os.tzdiff` computes the difference between the system's local time zone and UTC in minutes and a Boolean indicating whether daylight Saving Time is active for the given date. - The new function `stats.freqd` returns a frequency distribution function for a sample that can be iterated subsequently to return the number of all occurrences step by step. - The new `xbase.fieldtype` function returns the dBASE data type of the given field. - The new `xbase.write` function writes a number, string, or boolean to a dBASE file. It can be used instead of `xbase.writenumber`, `xbase.writefloat`, `xbase.writestring`, `xbase.writeboolean`, etc. - The new C API function `agn_checknonnegint` checks for non-negative integers. - The new C API function `agn_datetosecs` takes a structure or at least three numbers and returns the number of seconds elapsed since the epoch of the system (usually January 01, 1970). - The new C API function `agnL_createpairnumbers` puts a pair of two numbers on top of Agena's C stack. Improvements: - `hypot` has become around 40 % faster. `polar`, `approx`, `ilog2`, `calc.eucliddist`, `stats.neighbours` and various fractals package functions benefit from this increas in speed, as well. - `math.roundf` has become 13 percent faster. - `calc.eucliddist` now accepts multivariate functions and returns more precise results. - `calc.iscont` and `calc.limit` now can also process multivariate functions. If you would like give a self-defined epsilon, it must be passed as an 'eps':<value> option as the very last argument. For example, if the function is f := << (x, y) -> x + y >>, with x = 1, y = 3, and eps = 1e-4, the call would be: `calc.limit(f, 1, 3, eps = 1e-4)`. - `calc.diff` now can also process multivariate functions. If you want to pass a user-defined accuracy value h, pass the eps=h option as the very last argument instead of passing h as the third argument. - `calc.limit` can now return the left-sided limit by passing the side='left' option, the right-sided limit by passing the side='right' option, the left- and right-sided limit by passing the side='both' option; and the bidirectional, the left-sided, and the right-sided limits with the side='all' option. - `os.date`: the day of week ('wday' field) is now determined according to the ISO 8601 norm, where 1 is Monday, and 7 is Sunday. You may switch back to the old behaviour (1 for Sunday, 7 for Saturday) by issueing environ.kernel(iso8601 = false). - `os.date`: The '*j' (Julian Date) and '*l' (Lotus Serial Date) options have been re-introduced as they have been inadvertently removed in Agena 2.8.4. Contrary to the former results returned with the '*l' format, the function now returns correct values. - `os.now` and `os.settime` now accept year, month, and day, and optionally hours, minutes and seconds. - `os.date` now also accepts a table array of integers representing year, month, day, and optionally hour, minute, second. - `os.datetosecs` now accepts no argument at all and in this case returns the number of seconds elapsed till the current date and time. - When passing `false` as the last argument to `os.lsd`, the function acknowledges daylight saving time (by default, the function always returns a Standard Time value even if Daylight Saving Time is active for the given date). - `astro.cdate` now also returns hours, minutes and seconds in ordinary sexagesimal notation. - In Windows and eComStation, `os.realpath` now by default returns a path with slashes instead of backslashes. You can override this by passing `false` as a second option. - `stats.obcount` and `stats.obpart` can now be passed the number of classes into which a distribution shall be subdivided with the new 'classes' option. Also, if no third argument is passed to the function, it automatically computes the step size (aka class width), with no upper limit (it is suggested to choose between 5 or 30 classes). - `stats.obcount` now accepts an optional fourth argument, a procedure that is applied on any element of a distribution before the function decides into which subinterval to sort it for the final count. - Improved memory allocation error management of `stats.quartiles` and `stats.fivenum`. - Improved error handling of `stats.checkcoordinate` `math.inttofpb`, `math.tobinary`. - `xbase.new` now also accepts the data type name 'Numeric' which is equal to 'N' and 'Number'. (There is no dBASE data type called 'Number'.) - The xbase package now supports signed 4-byte integers (Visual Fox Pro 'I' or 'Long' data type). Use `xbase.writelong` or `xbase.writenumber` to write 4-byte integers to a dbf file. The function automatically truncates Agena numbers to their integral part and issues an error if the numeric range [-2'147'483'647, +2'147'483'647] is exceeded. Longs can be read by LibreOffice 5.x Calc, but not by Excel. - The xbase package now supports timestamps (Visual Fox Pro 'T' data type). Use `xbase.writetime` to write them. - dBASE binary Double values can now be read by LibreOffice 5.x Calc. They can still not be read by current Excel editions. - `xbase.attrib` now also returns the dBASE version number. - `xbase.new` can now be given an explicit dBASE version number with the new version=x option. (See documentation of `xbase.new` for valid values for x). If no version option is passed, then by default the dBASE version is 0x03 = 3 decimal = dBASE III+. If at least one of the given fields is of type 'Double', then the version number is automatically changed to 0x30 = 48 decimal = Visual Fox Pro. This allows dBASE files created with Agena and containing binary Doubles to be imported into LibreOffice 5.x. Current versions of Excel still cannot read Visual Fox Pro dbf files, so you might pass the version option. - Besides xBASE doubles, `xbase.writenumber` can now also write xBASE floats, longs, and binary doubles. Thus, you must no longer need to check whether to use `xbase.writefloat`, `xbase.writelong`, or `xbase.writedouble`. Also improved error message. - The manual has been improved. Bug Fixes: - `calc.limit` sometimes returned wrong results with removable singularities. This has been fixed. - The already documented `hypot2` function has now been implemented. It computes sqrt(1 + x^2), avoiding over- and underflows. - `os.lsd` works again if one or more arguments have been passed to it, and also now returns a correct result with dates before March 01, 1900. - `os.settime` now works as described in the manual. - `os.drivestat` and `os.settime` are available (again) in Linux. - `zx.genseries` always crashed. This has been fixed. - `utils.readcsv` now returns an error if both enclosing single and double quotes shall be removed from field values. - `skycrane.readcsv` now by default only deletes enclosing double quotes; single quotes around fields can no longer be removed. - `stats.obcount` and `stats.obpart`: The following feature does now work as described in the manual: "[...] if an element in a distribution equals the right border of the overall interval, it is considered part of the last subinterval." - `math.tosgesim` has been rewritten in C, improved in precision and no longer returns the second or minute 60 or greater. It has also become 30 percent faster. - `math.nthdigit` could not retrieve a digit in the fractional part of a number. This has been fixed. - `mdf` and `xdf` rounded all numbers to the wrong direction. This has been fixed. Thus, `xdf` can now be used to truncate floats to a given decimal place. - `gdi.pointplot` may not have worked when evaluating thickness and linestyle options. This has been fixed. - `os.drivestat` might not have worked in Sun Solaris. This has been fixed. 2.9.7, February 01, 2016 - The new `intdiv` statement conducts an integer division of its operands and reassigns the result to the first operand. - The new function `calc.iscont` returns `true` if a real function is continuous at a given point, and `false` otherwise. - The new function `calc.limit` returns the limit of a function at a given point. - The new function `calc.eucliddist` computes the Euclidian distance, i.e. the straight-line distance, of two points on a curve defined by a function in one real. - The new function `calc.arclen` returns the arc length (curvilinear length) of a function in one real between two points. - The new function `calc.sinuosity` computes the ratio of the curvilinear length and the Euclidean distance between the end points of a curve. - The new function `calc.symdiff` computes the symmetric derivative of a function at a point. The function is three times faster than `calc.xpdiff`, but a little less accurate. - `math.eps` can now also compute a `mathematical` epsilon value that also takes into account the magnitude of its argument, by passing any second argument. It prevents huge precision errors with computations on very small and very large numbers. - `environ.kernel` returns the maximum path length with the 'pathmax' option. - `clock.tm` has been tuned. - Added another fix to `math.convertbase` with respect to the internal stack used. - `utils.readcsv` did not correctly strip empty quoted fields and fields enclosed by quotes containing delimiters - this has been fixed. - `approx` returned a wrong result (i.e. `true`) if at one of its first two arguments was `infinity` and the other one was finite. This has been fixed. - In Windows, when pressing CTRL + C to quit the interpreter, the warning `This application has requested the Runtime to terminate it in an unusual way. Please contact the application's support team for more information.` should no longer be issued. - The test suite has been corrected. - The number of internal number stacks has been extended from one to three stacks. You can switch between them by calling the new function `switchd` with its argument between 1 and 3. The default is stack #1. The new function `stack.selected` returns the currently selected/active stack. When given a stack number, `allotted` returns the current number of values in the given stack. `stack.resetd` now also accepts one or more stacks to be cleared by passing their number(s). - The new function `stack.sorted` sorts all or the last given number of elements in the stack in ascending order. - The new function `stack.choosed` returns the number of the stack with the least number of stored values. - `stack.reversed` did not correctly check negative arguments. This has been fixed. - `pushd` can now insert values into a given stack by passing the stack = <stack number> option as the last argument, avoiding explicit stack switches with calls to `switchd`. Using this option, however, may slow down the operation since processing an option takes quite some computation time. You may be better off calling `switchd`. 2.9.6, January 03, 2016 - The `create table` statement can now pre-allocate both the array _and_ hash parts of a new table, e.g. `create table a(10, 200)`. - `math.convertbase` generally cleared the built-in numerical stack and thus could interfere with other functions still needing it. This has been changed. - In Windows, the `bye` statement sometimes caused unnecessary warnings of the operating system. This has been fixed by now conducting a final standard garbage collection and completely closing the state of the interpreter. - `os.exit` now by default clears the interpreter state before leaving. The description of the function in the manual has been corrected, too. - `pushd` now accepts a sequence of numbers to be added to the built-in number stack. - `stack.reversed` can now reverse the last n values pushed onto the stack, e.g. `stack.reversed(n)`. - `resetd` has been moved to the `stack` library. An alias to this former base library function has been added for backward compatibility. - If the initialiser of `tables.dimension` is a structure, the function now creates an indidual copy of it to avoid referencing to the same structure. This was the behaviour of the former `dimension` baselib function. - The `mapm` package did not correctly free some of the consumed memory at exit. This has been fixed. Also, the garbage collection of the package trims the memory usage to significantly reduce general footprint of this library. - In Debian, the `gdi` package has been recompiled and hopefully would now only need the zlib package as a dependency ... Also, libexpat2 and libgd2-xpm are no longer pre-requisites for the Debian installer. 2.9.5, December 30, 2015 - The new function `math.tobinary` converts a non-negative integer into its binary representation, a sequence of zeros and ones. - The new function `tables.newtable` returns a table with a given number or pre-allocated array and hash slots. - `dimension` has been completely rewritten and can now create any kind of n-dimensional table. The function has also been moved to the `tables` library (new function `tables.dimension`). An alias to the former `dimension` function in the basic library has been added for backward compatibility. - The `to` indexing method for tables did not work properly with some types of index ranges and in theses cases wrongly returned all elements in the array part of a table. This has been fixed. - With structures, the `case/of` statement now compares values for strict equality (like the `==` operator). Formerly, a Cantor-like equality check has been conducted where positions and the number of occurence of elements in a structure do not matter. - `stack.dumpd` can now also dump the last n values pushed onto the stack. - If `ads.iterate` receives a file handle only, the very first key ~ value pair in the base is returned (same as passing the empty string as the second argument). The function now can also read sequences: in this case, the function returns an iterator function that when called returns the next entry in the sequence database. - `ads.getall` now returns an Agena sequence of all the entries stored in a sequence database if any second argument is given. The entries are returned in the order of their physical presence in the database file; if one and the same entry is stored multiple times, it is returned multiple times. - `ads.createbase` now returns nothing, since returning the handle of a closed file did not make sense. - Memory leaks in `ads.createbase` and `ads.iterate` have been removed. - `ads.filepos` has been documented. 2.9.4a, December 26, 2015 - Windows only: Due to a very kind hint by an Agena user, the missing dynamic link library libgcc_s_dw2-1.dll needed by the gdi and gzip packages has been added to the Windows installers. 2.9.4, December 07, 2015 - The new function `stats.midrange` computes the sum of the minimum and maximum value of a distribution, divided by two. - The new `|` operator compares two finite numbers a, b, determines whether a is less than b, a is equal to b, or a is greater than b, and returns -1, 0, or 1 respectively. - A numerical stack has been built into Agena. It can store numbers only. See Chapter 7.41 of the Primer and Reference for details. - Agena for Windows has been recompiled with GCC 4.8.1. The binaries are around 20 percent faster now. - `math.tobytes` had been rewritten for it did not work correctly if Agena had been compiled with GCC 4.8.x or higher. Thus, it now also works in DOS. - `mapm.xtonumber` could not convert a mapm arbitrary precision number into an Agena number. This has been fixed. - Improved error messages of `gzip.lines` and of `run`. - Some source files have been cleaned up, so Agena should compile better with very pedantic C compilers. - Extended the test suite. 2.9.3, November 17, 2015 - The new `// ... \\` constructor allows to define a table of constant numbers and/or strings the simple way: items may not be separated by commas, and strings do not need to be put in quotes as long as they satisfy the criteria for valid variable names (name starting with a hyphen or letter, including diacritics). Records are supported as well. Expressions like `sin(0)` etc. are _not_ parsed. Example: > a := // 0~0 1 2 3 zero one two three '2and3' \\: [0 ~ 0, 1 ~ 1, 2 ~ 2, 3 ~ 3, 4 ~ zero, 5 ~ one, 6 ~ two, 7 ~ three, 8 ~ 2and3] - The new function `math.wrap` conducts a range reduction of a number to a given interval [min, max). - The new `inrange` operator checks whether a number is part of an interval. It is five times faster than the `in` operator. "inrange(x, a, b)" is equivalent to "x in a:b". - C-style comments ( /* ... */ ) are now supported. - The `**` operator turned into an infinite loop if the exponent was +/- `infinity` or `undefined`. This has been fixed. - The new `zx` package provides various elimentary mathematical functions implementing Chebyshev polynomials for sine, cosine, tangent, arcus sine, arcus cosine, arcus tangent, natural logarithm, exponentiation to the base E, general exponentiation, and square root. These functions are C implementations of the corresponding Sinclair ZX Spectrum 48k ROM Z80 assembler routines. Furthermore, some auxiliary functions are provided to directly compute Chebyshev polynomial with a given coefficient vector, to reduce the range of arguments, and to retrieve or change Chebyshev coefficients. For completeness, pendents of all other ZX Spectrum math and Boolean functions are available, as well. 2.9.2, November 04, 2015 - The new `utils.uuid` function creates a random version 4 universally unique identifier (UUID), or the nil UUID. - `os.exit` now closes the state of the interpreter before leaving for the operating system if its last argument is the Boolean `true`. - In eComStation, the 'halt' switch to `os.terminate` can now halt the system, but it does not power it off. - The new `registry` package provides limited access to the registry and should be used instead of the `debug.getregistry` function. - The `system` function in the `debug` library has been moved to the `environ` package. An alias has been provided for backward compatibility. - Garbage collection has been changed when deleting set entries via indexing. - In the manual, the chapters on sandboxes and scripting have been improved. Also, userdata, lightuserdata, and the registry are now briefly described. The Crash Course has been extended, as well. 2.9.1, October 30, 2015 - The new `++` operator returns the next representable number larger than its argument. Likewise, `--` returns the next representable number smaller than its argument. They can be used to create open intervals, e.g. "1 in ++1 : --2" returns false, and use the same underlying C function as math.nextafter. With variables passed as arguments, the operators do not modify, i.e. increase or decrease, them (see `inc` and `dec` statements instead). - `put` now supports registers. - With sets, the standard assignment `setname[key] := value` is now supported. If value is `null`, key is deleted from the set. If value is not `null`, key is added to the set. - `rawset` can now delete a value from a set by passing the value as the second and `null` as the third argument. - The new function `numarray.purge` removes a given element from an array. - `numarray.include` can now insert a single number instead of an array into a numarray. - The new function `numarray.used` returns the estimated number of bytes consumed by the given array. - Arrays can now be reduced to zero size by `numarray.resize`. - When shrinking an array, `numarray.resize` no longer fills slots to be deleted with zeros. This prevents arrays from being modified if memory re-allocation fails. - The new environ.kernel/readlibbed setting returns a set of all the libraries imported in a session. The equivalent package.readlibbed set may be deprecated in the future. Likewise, environ.kernel/loaded returns the names of all standard libraries available after start-up. - The `insert` and `delete` statements did not cope well with complex expressions, e.g. "insert 1 into f.g(x)", with function f.g returning a structure. This has been changed. - With metamethods attached to tables, sequences and registers, the `insert` statement either failed or incorrectly added a value. This has all been fixed. - The `delete` statement did not support metamethods and thus allowed to purge values from structures protected by a proper read-only metamethod. Now, the delete statement supports metamethods: it passes `null` as the value and the data to be deleted as its key to the __writeindex metamethod. To protect values stored to structures you might define: > readonly_mt.__writeindex := proc(t, k, v) is > if unassigned v or assigned rawget(t, k) then > error('cannot delete or modify') > else > rawset(t, k, v) > fi > end; - The `pop`, `rotate`, `duplicate`, and `exchange` statements now issue an error if a structure features a __writeindex metamethod. This prevents read-only structures from being modified. - The `restart` statement did not delete loaded metatables from the environment. This has been fixed. - In DOS, `math.tobytes` did not work. The function now just returns `fail` on this operating system. - Improved the manual. 2.9.0, October 23, 2015 - The new `case of <condition>` syntax flavour is an alternative to the `if` statement, similar to the `switch` statement in the Go programming language. It may improve the readability of code. Example: > case > of x < 0 then return -1 > of x = 0 then return 0 > else return 1 > esac - `case` statements can now check whether numbers or characters are included in ranges, e.g.: > case value > of -1 to 1 then return true > of 'a' to 'c' then return true > esac - In `case` statements, the arrow token (->) can be used instead of the `then` keyword. - The new `odd` operator checks for odd numbers (integers). - The new `mod` statement computes the modulus of its operands and reassigns the result to the first operand. - The new function `math.isinfinity` checks for positive or negative infinity in one call. - The new `numarray` package implements arrays of C doubles, 32-bit integers, and unsigned chars and can also read and write binary files. - `math.tobytes` can convert an integer into a sequence of four bytes if given the optional number 4. Likewise, `math.tonumber` can convert a sequence of four bytes to a number. - The `environ.kernel/minlong` and `environ.kernel/maxlong` settings have been moved to `debug.system`. Two new constants have been added to the math package: `math.smallest` and `math.largest` represent the smallest and largest positive representable number and - contrary to the debug.system settings - are computed and assigned during start-up. - In Solaris, eComStation - OS/2, and DOS, the `abs` operator returns a more precise result with complex numbers. - `environ.kernel` can now return the smallest positive and largest representable Agena number (= C double). More number ranges have been added to `debug.system`. - Sometimes the `print` funtion printed one and the same table value with a numeric key twice. This has been fixed. - `calc.linterp` and `calc.polygen` could possibly crash Agena, this has been fixed. - In Windows 2000 and earlier, `os.cpuload` crashed Agena. This has been fixed. - Corrected error message of `llist.purge`. - The `hashes` package accidently also stored its package table to the registry. This has been changed. 2.8.6, September 29, 2015 - The new function `math.rint` rounds a float to an integer according to the current rounding mode (see environ.kernel/rounding). - The new function `os.realpath` converts each pathname argument to an absolute pathname, with symbolic links resolved to their actual targets and no . or .. directory entries. - The new function `os.strerror` returns the text message for the given error code, or the latest error issued by the underlying operating system. - `os.setenv` now allows to remove environment variables by passing the second argument `null` (as already mentioned in the manual). - A potential memory leak has been removed from the Windows version of `os.getenv`. - Agena crashed in the Windows edition of `os.setenv` if the environment variable name or its value exceeded 32,766 characters. This has been fixed. - The new command-line option `-s` issues a user-defined slogan at start-up. - The new command-line option `-x` surpresses the initialisation of the main Agena library file lib/library.agn at start-up. Setting this switch may be useful for debugging purposes only, or to save memory. Many functions, however, will not be available if this option is used. - The `-n` (do not run initialisation file(s)) command-line switch has been ignored by the `restart` statement. This has been fixed. - The new `environ.kernel` settings `skipinis` and `skipmainlib` control whether Agena initialisation files and the main Agena library are loaded during a `restart`. - The new `environ.kernel` setting `rounding` sets or retrieves the current rounding mode. - `environ.kernel`: Agena could crash when reading or changing the `digits` setting. This has been fixed. - The new C API functions `agn_isvalidindex` and `agn_stackborders` determine valid stack positions. The functions may be useful for debugging purposes, only. 2.8.5, September 01, 2015 - `antilog2` and `antilog10` now automatically use the same function called by the `^` exponentiation operator (i.e. C's pow) if their arguments are out of the bounds +/- 308.2547155599167 and +/- 1024, respectively, instead of simply returning 0 or `infinity`. - The new `xnor` operator implements the if-and-only-if Boolean operator which return true if both its operands are the same, and `false` otherwise. - With functions of two arguments called like binary operators: before, only simple names could be used in the call expression; now, indexed names and even esoteric calls to functions returning functions are allowed, as well: > add := << x, y -> x + y >>; > 1 add 2: # -> 3 > t := [add = << x, y -> x + y >>]; > 1 t.add 2: # -> 3 > 1 t['add'] 2: # -> 3 > subtract := proc() is return << x, y -> x - y >> end > 2 subtract() 2: - The new function `math.fdima` returns x - y if x >= y, and a default otherwise. - `os.system` could not detect properly detect Windows 10. This has been fixed. - `os.unmount` crashed in Sun Solaris 10. This has been fixed. - The plus library DLL files in the portable Windows version of Agena 2.8.4 had been out-of-date. This has been changed. - `xor`, `nand`, and `nor` have been tuned a little bit. 2.8.4, August 23, 2015 - The new function `math.quadrant` returns the quadrant of an angle given in radians and returns an integer in [1, 4]. - The new function `math.fdim` returns x - y if its argument x is greater than y, else returns 0. - The new function `math.isminuszero` checks for minus zero (-0). - The new function `math.symtrunc` returns its argument if it is in a given range, and a default otherwise. - In Windows, Solaris, and Debian, `math.signbit`, `math.isordered`, `fma`, `finite`, `log2`, as well as `int`, `frac` and their related functions now use C functions provided by the underlying platform instead of self-defined implementations. - `math.signbit` now returns correct values on formerly unsupported platforms, instead of just zero. - Both `antilog10` and `antilog2` have become five times faster by using the respective Cephes Math Library implementations. Please note the new ranges for the arguments: +/- 308.2547155599167 and +/- 1024, respectively. If the argument is out of these bounds, the operators return 0 or `infinity`. For very small arguments, you might use the `^` operator. - `stats.prange`, `stats.iqmean`, `stats.trimean`, `stats.quartiles`, `stats.fivenum`, `stats.smm`, and `stats.gsmm` now use the introsort algorithm to sort observations instead of traditional recursive Quicksort, to speed up computation times. - Positive numbers can now be preceded with the `+` token, as asserted in the manual. This will not effect anything. - `os.cpuload` crashed in Windows 2000 and earlier. This has been fixed. - `os.symlink` may have crashed in Windows. This has been fixed. - The `to` statement (not the `for` statement) could corrupt the stack in Agena 2.8.3. This has been fixed. - Fixed the -0 constant bug when loading or running script files. - Minor change to `os.system` et al: future Windows releases beyond 10 are now properly handled, provided no Win API changes will be made. - `os.terminate` is no longer available in Mac OS X since the Carbon framework formerly being linked caused memory leaks in Agena. - Improved the scheme files and parts of the Primer and Reference. 2.8.3, July 29, 2015 - A new flavour of the `with` statement is available: with <name> do: within the body of this statement, the table <name> can be referenced by just an underscore. It also allows to actively change values in the table <name>. Example: > zips := [duedo = 4000, bonn = 5300] > with zips do > print(_.bonn); > _.bonn := 53111 > od 5300 > zips: [bonn ~ 53111, duedo ~ 4000] This is syntactic sugar for: > scope > local _ := zips; > print(_.bonn); > _.bonn := 53111 > epocs All flavours of the `with` statement now allow its block to be surrounded by the `do` and `od` - instead of the `scope` and `epocs` keywords - just as allowed by Modula-2. - Numeric `for` loops with stop value 0 (zero) and a fractional step size did not stop at 0 but one step before. This has been fixed. Optimised internals of numeric for loops, as well. - The new function `rot` rotates a two-dimensional vector, represented by a (complex) number, through a given angel. - The new function `everyth` returns every given k-th element of a structure and returns a new structure. - `stats.iqr` has become six times faster if the distribution is unsorted. - `tanc` has become twelve percent faster. - The new function `stats.qcd` determines the quartile coefficient of dispersion. - `math.dms` returned imprecise results. This has been fixed. The function has also become 25 percent faster. - `math.random` behaved poorly if called with no arguments. This has been fixed. 2.8.2, July 14, 2015 - The new function `calc.ibeta` implements the incomplete beta integral. - The new function `calc.invibeta` evaluates the inverse of the incomplete beta integral. - `stats.acf` now optionally accepts a pre-computed arithmetic mean and the sum of all values in a distribution. This option reduces computation time to a third. - The new `tanc` function returns tan(x)/x for real or complex x <> 0, and 1 for x = 0. - The new `stats.invnormald` implements the inverse Normal distribution function. - The arguments of `calc.igamma` and `calc.igammac` have been swapped to comply with related integral functions. - `stats.gammadc` evaluated the Gamma distribution function instead of the complemented one. This has been fixed. - `calc.polygen` does not accept more than 256 arguments any longer for this could corrupt an internal stack. - The following functions now properly free internal memory in case of errors: `stats.acf`, `stats.acv`, `stats.prange`, `stats.neighbours`, `stats.nearby`, `calc.interp`, `calc.newtoncoeffs`. 2.8.1, July 07, 2015 - `stats.trimean` now optionally accepts a given percentile rank determining the lower and upper margin. - The new function `stats.fivenum` returns the five-number summary of a distribution, plus the arithmetic mean. - The new functions `calc.Ai` and `calc.Bi` compute the Airy wave functions and their respective first derivatives. - The new `calc.zeta` function computes the Riemann zeta function. - The new `calc.polylog` function computes the polylogarithm of a given order and point in the real domain. - The new function `calc.En` computes the exponential integral int(exp(-x*t)/t^n, t = 1 .. infinity). - The new `calc.igamma` evaluates the incomplete gamma integral. - The new `calc.igammac` evaluates the complemented incomplete gamma integral. - The new `stats.gammad` Gamma distribution function returns the integral from zero to x of the gamma probability density function. - The new `stats.gammadc` complemented Gamma distribution function returns the integral from x to infinity of the gamma probability density function. - `calc.polygen` has become twenty times faster by using the same technique to access internal data as `calc.linterp` has done. The former bug that wrong results have been returned when passing more than 254 coefficients thus has also implicitely been fixed. - The index of the Primer and Reference, and the Crash Course have been improved, as well. 2.8.0, June 23, 2015 - The new `with` statement unpacks values from a table, declares them local and then is able to access them in a block. The new names are variables on their own and do not refer to the indexed values in the table: zips := ['duedo' ~ 40210:40629, 'bonn' ~ 53111:53229, 'cologne' ~ 50667:51149]; with duedo, bonn in zips scope print(duedo, bonn, cologne); duedo := null # zips.duedo is not changed epocs; -> 40210:40629 53111:53229 null print(zips.duedo) -> 40210:40629 - The former `with` function has been renamed to `initialise`, but there are no changes to the `import` statement. - The assignment statement has been extended to unpack values from a table, the `local` statement is supported, as well. Thus, duedo, bonn in zips is equal to (local) duedo, bonn := zips.duedo, zips.bonn Both extensions are based on a Lua 5.1 power patch written by Peter Shook. - Record fields in tables can now be defined more easily by using the equals sign separating the - unquoted - record field name and the corresponding value. Thus, zips := ['duedo' ~ 40210:40629, 'bonn' ~ 53111:53229, 'cologne' ~ 50667:51149]; is equal to zips := [duedo = 40210:40629, bonn = 53111:53229, cologne = 50667:51149]; The old way to define record fields using tildes is still supported. Both styles can be mixed: zips := ['duedo' ~ 40210:40629, bonn = 53111:53229, cologne = 50667:51149]; Please note that if you want to enter the result of a Boolean equality check into a table, use the `==` token instead of the `=` sign. - `os.date` can return the Julian date if given the new '*j' format, or the Lotus 1-2-3 Serial Date if given the new '*l' format. - The new function `os.lsd` computes the Lotus 1-2-3 Serial Date, which is also used in Excel (known there as `Excel Serial Date`), where January 01, 1900 is day 1. It returns a number. (Day 60 = non-existent February 29, 1900 is properly handled.) - `os.now` also returns the Lotus 1-2-3 Serial Date with the 'lsd' key. - `xbase.writedate` now accepts both strings and numbers as the date to be written to a dBASE file. - `os.time` did not check for the existence of a given date and returned miraculous results with invalid dates. This has been fixed. - Remember tables sometimes failed returning a cached result if too many entries have been stored to them. This bug has been fixed. - The initialisation routine that searches for the main Agena library has become stricter to avoid unneccessary problems in UNIX. - The `values` operator has been fixed to avoid problems with strict equality checks (`==` operator). - On the interactive level, i.e. the Agena prompt, diacritics defined in the ISO 8859/1 Latin-1 codepage can now be part of names. Please note that within scripts stored to a file, diacratics still are not allowed within names. - Deprecated `stats`, `linalg`, and `xbase` functions now are correctly initialised in the compat.agn compatibility file. 2.7.0, June 12, 2015 - Formerly, only one expected type of return could be defined for procedures, now you can specify up to four basic types by putting them in curly brackets, e.g.: > f := proc(x) :: {number, complex} is return 'a' end > f() In stdin at line 1: Error in `return`: unexpected type string in return. - There has been a subtle change on how Agena treats the last iteration value of numeric for loops if such loops are executed _on the interactive level_, i.e. not within a function: if the loop is part of a block, then the last iteration value now is accessible only in this `scope` block, but not in outer blocks: > scope > for i to 10 do od; > print(i) > epocs 11 > print(i) null > for i to 10 do od > print(i) 11 This fix has been applied to comply with the description in the Primer and Reference, so that the behaviour now is the same both with functions and the interactive level. - If you assign a procedure to `environ.onexit`, then when quittung Agena with `bye`, `os.exit`, or CTRL-C, this procedure will be called before exiting the interpreter. The procedure is also called when issuing the `restart` statement. Thus you may conduct file system clean-up, pass back information if Agena is being piped, save variables to disk, or anything else. - Remember tables can now already be assigned during procedure definition: just put the statement `feature reminisce` right after the `is` keyword. You may thus save an explicit call to `rtable.rinit` after the procedure has been defined. Thus, also anonymous procedures support remember tables now. - `os.system` can now directly detect Windows 10 and Windows 10 Server. The function also now correctly acknowledges Windows Server 2012 R2. - The `tar` package (UNIX tape archive reader) has become a part of the Agena distribution. - The new function `gdi.lineplot` plots lines between 2-dimensional points. It is just an easy-to-use wrapper around `gdi.pointplot` with the connect = true option. - `gdi.pointplot` with the connect = true option now supports the `thickness` and `linestyle` options for lines. - `gdi.setline`, `gdi.setcircle`, `gdi.setarc`, `gdi.setellipse`, `gdi.setrectangle`, `gdi.settriangle` now accept a thickness value as the very last argument. By default, it is 1 (= normal). - The new function `math.decompose` splits an integer of any base into its digits. - `math.ndigits` has been ported to C, and processes non-positive values, as well. It has not necessarily become faster. - The new C API function `agn_checkposint` checks whether a value is a positive integer. - The new C macro `lua_regsetinumber` sets an Agena number to the given index of a register. - The scheme files have been improved. - `environ.attrib` now checks whether a register has been assigned a user-defined type. 2.6.1, May 27, 2015 - A slightly improved version of the tar package including better documentation has been uploaded: http://sourceforge.net/projects/agena/files/Packages/tar.agn/download. - Chapter 6.24 of the Primer and Reference on object-oriented programming has been extended: http://sourceforge.net/projects/agena/files/Manuals/agena.pdf/download. 2.6.1, May 25, 2015 - `environ.kernel` returns all current kernel settings when called with no argument. - In Windows, eComStation, and UNIX incl. Mac OS X `os.memstate`, now also returns the page size in bytes. If the memory status could not be determined in eComStation, then `os.memstate` now returns a table with all the values set to `undefined` instead of just returng `fail`. - `os.fattrib` now accepts a number (representing an octal value, like the argument to the UNIX chmod command)to change the mode of a file, so for example UNIX `chmod 755 file` = Agena `os.fattrib(file, 0o755)`. - `strings.tochars` now also accepts a sequence of numbers (unsigned chars) to be converted to a string. - The new function `binio.lines` creates an iterator that returns a line in a file step-by-step. - The new function `binio.isfdesc` checks whether a file handle is valid. - `binio.rewind` now accepts an optional position. If given, the function resets the file pointer to this position relative to the beginning of the file. - The new function `math.tobytes` returns a sequence with all the bytes of a number in Little Endian order. - The new function `math.tonumber` takes a sequence of numbers representing bytes and converts it into an Agena number. - The error messages of various I/O functions in the io and binio packages now give more detail. - `strings.tochars` has been patched to cope with embedded zeros. - `os.fattrib` could not change the date and time of files. This has been fixed. Also, in UNIX, `os.settime` issued errors - this has been fixed, too. - Corrected error messages of `os.datetosecs`. - The `ignorespaces` default (formerly true) has been changed: now `utils.readcsv` does not delete spaces in 1fields any longer. Also, if fields are enclosed in double qoutes, the function also automatically deletes these quotes. You can set the new `removedoublequotes = false` option to avoid this. - Agena for Windows now runs around 10 % faster, as it has been compiled with MinGW/GCC 4.5.2 instead of 4.6.2. - Two new packages have been uploaded to http://sourceforge.net/projects/agena/files/Packages: - a package to list, read, and extract individual files from a UNIX tar archive, and - a package called `Agner` with phone line availability formulaes developed by Danish Scientist Agner Krarup Erlang. Please see the respective Agena source files for the documentation. 2.6.0, May 10/11, 2015 - You can now `define` your own binary operators just by using functions of two arguments, > plus := proc(x, y) is return x + y end; the following way: > 1 plus 2: 3 When using a function as a binary operator, it has always the highest precedence. - Agena now supports OOP-style methods. To define a method for a table object, > account := ['balance' ~ 0] enter something like (please note the two `@` tokens): > proc account@@deposit(x) is > inc self.balance, x; > return self.balance > end The name `self` always refers to the table object. Call the method using two `@` characters: > account@@deposit(100) Query the object. > account: [balance ~ 100, deposit ~ procedure(016D6820)] For more information, check http://www.lua.org/pil/16.html. - Added `divs.asine`, `divs.acosine`, `divs.asecant`, `divs.hsine`, `divs.hcosine`, `divs.htangent` and the proper metamethods for the arcsin, arccos, arcsec, sinh, cosh, and tanh operators, to the `divs` package. The `recip` and `~<>` operators now also support fractions. - The new `<<<<` and `>>>>` operators return the number x (left operand) rotated a given amount of bits (right operand) to the left or the right. - `inc`, `dec`, `mul`, and `div` accepted function calls as the first argument. This has been fixed. - The `linalg` package now supports the division operator for vectors, and the `~<>` operator for both vectors and matrices. - Some `linalg` functions have been marginally improved with regards to runtime behaviour. - The list of available metamethods in Appendix A2 of the Primer and Reference has been extended. - The `shift` operator has been removed. Please use the `<<<` operator for left-shift operations, and `>>>` for right-shifts. An alias, however, has been provided for backward compatibility. - Extended the scheme files. - The undocumented reserved words `algform` and `kthmoment` have been removed. - The agena-2.6.0-win32-gcc452* installers feature a Windows version of Agena that runs around ten percent faster. 2.5.4, May 06, 2015 - Due to a suggestion by a forum user, you may now include double quotes in a string delimited by single quotes without using a backslash. The same applies to single quotes embedded in a string delimited by double quotes, e.g. "'agena'" is now a valid string. - `inc`, `dec`, `mul`, and `div` accepted function calls as the first argument. This has been fixed. - The `typeof` operator could not determine user-defined types for userdata. This has been fixed. - The `cls` and `bye` statements can now be included in chunks (e.g. loop or procedure bodies), there are no longer syntax errors. Thus, os.execute('/usr/bin/clear') or os.exit() statements in chunks are no longer needed. - Two variables in `gdi.plotfn` had been declared global. This has been fixed. - The Linux build scripts have been corrected. 2.5.3, April 26, 2015 - A non-yum based WarpIN installer of Agena for eComStation has been uploaded due to a kind hint from Serenity Systems, Italy. 2.5.3, April 12, 2015 - Due to an idea from Serbia, a new type check metamethod '__oftype' has been introduced for all structures and for userdata. If a type check metamethod exists for such an object, then it is run with calls to the :: and :- operators. If the object does not satisfy the criteria defined in the metamethod, then Agena returns `false`. This also applies to function calls: if the check fails, Agena issues an error, e.g.: > mt := [ '__oftype' ~ proc(x) is return type(x) = pair and left(x) :: number and right(x) :: number end ]; > duo := 1:2; > setmetatable(duo, mt); > f := proc(x :: pair) is return x end; > f(duo): 1:2 > duo := 'a':'b'; > setmetatable(duo, mt); > f(duo): In stdin: argument #1 does not satisfy type check metamethod '__oftype' metamethods can also check results to procedure calls if an expected result type is specified in a procedure definition (e.g. `f := proc(x :: pair) :: pair is return x end;`). - User-defined types can now also be set to registers. - `stats.sumdataln` returned incorrect results. This has been fixed. - `stats.gmean` has been rewritten using logarithmic sums and now is twice as fast. - The new function `stats.meanvar` returns both the artithmetic mean and the variance of a distribution. - The new function `stats.standardise` normalises a distribution so that they become comparable. - The new function `stats.covar` computes the covariance of two distributions. - The '__sin' metamethod has been removed. 2.5.2, April 07, 2015 - `gdi.plotfn` now can also plot graphs of high slope functions correctly thanks to a contribution by a Serbian user. - The following binary operators are now at least thrice as fast: `xor`, `atendof`, `&&`, `||`, `^^`, `~~`, `<<<`, `>>>`, `::`, `:-`, `*%`, `/%`, `+%`, `-%`, `@`, and `$`. - The new `~<>` binary operator checks whether two numbers or complex numbers are not approximately equal, i.e. it is the negation of the `~=` operator. - The new `nand` and `nor` operators are the negations of `and` and `or`, respectively. - The new function `stats.cauchy` returns the probability density function 1/(Pi*b*(1+((x-a)/b)^2)), of the Cauchy distribution. - The new function `stats.sumdataln` sums up the natural logarithms of the observations in a distribution. - The new functions `stats.durbinwatson` tests the autocorrelation in the residuals from a linear regression. - The functions `stats.sum` and `stats.sumdata` have been merged, i.e. `sumdata` now also accepts a data selection function. `stats.sum` has been deprecated, but an alias is provided for backward-compatibility. - Most statistics functions now ignore `infinity` and `undefined` if present in tables. With sequences, the functions have already skipped these non-finite values. 2.5.1, March 30, 2015 - Agena allowed to start a string with a single quote and finish it with a double quote, and vice versa. This has been changed: string delimiters must now either be single or double quotes. - Besides including one or more single quotes within a number to group digits, also underscores (like in Ada) can be used. Underscores and single quotes, however, cannot be mixed. - Functions alternatively can be defined using the Algol-like syntax: proc <name>(<arguments>) is <statements> end, which is equal to <name> := proc(<arguments>) is <statements> end. - The new `cis` operator computes the complex exponential function exp(I*x) = cos(x) + I*sin(x) for any real or complex argument x and is around 25 % faster than the equivalent expression exp(I*x). - If any Boolean is given as the last argument to `math.random`, then the sequence of random numbers should be arbitrary. - The new function `stats.chisquare` returns the probability density function x^((nu-2)/2) * exp(-x/2)/2^(nu/2)/gamma(nu/2), of the chisquare distribution. - The new function `stats.fratio` returns the probability density function gamma( (nu1+nu2)/2)/gamma(nu1/2)/gamma(nu2/2)*(nu1/nu2)^(nu1/2)* x^((nu1-2)/2) / ( 1+ (nu1/nu2)*x) ^ ((nu1+nu2)/2), of Fisher's F distribution. - The new function `stats.normald` returns the the probability density function exp( -(x-mu)^2/2/sigma^2 ) / sqrt(2*Pi*sigma^2), of the normal distribution. - The new `stats.studentst` function returns the probability density function gamma( (nu+1)/2 )/gamma(nu/2)/sqrt(nu*Pi)/(1+t^2/nu)^((nu+1)/2), of the Student's t-distribution. - `stats.skewness` can now compute the sample skewness of a distribution by passing an optional argument. - The new function `stats.kurtosis` determines the kurtosis (peakedness) of symmetric and unimodal distributions. - `skycrane.dice` now creates truely random numbers. - Agena cow correctly returns `undefined` with the numeric expressions 0^0 and 0**0. For the sake of speed of the exponentiation operators, it still incorrectly returns 1 instead of `undefined` for infinity^0. 2.5.0, March 23, 2015 - `utils.writecsv` can now also write a header and enclose each value with a given string. Also, any option can now be given in the form `option = value`. The old way of sequentially passing options is still supported. - `stats.gmean` has been rewritten for it returned wrong values with distributions containing very small or very large values provoking underflows or overflows. Also, the function no longer returns complex values if the sign of the product of all observations is negative (returning `undefined` instead), and issues an error if the distribution contains complex values for it now computes in the real domain, only. The function has become twice as fast. - `<<<`, and `>>>`, `stats.skewness`, and `fractals.dragon` have been tuned a little bit. - `unpack` with a given register may have crashed Agena if the interpreter had not been compiled with GCC. - The `shift`, `<<<`, and `>>>` bitshift operators could crash Agena when called with non-numbers. This has been fixed. - Registers had not been correctly garbage-collected, leading to out-of-memory errors with large registers. This has been fixed. - The test suite now properly cleans up the namespace. - The manual and the scheme files have been corrected. - The following deprecated operators and functions have now been removed, the following list includes their substitutes right after the `->` token. Except is/si and ->, all of these functions can be used by running the `/lib/compat.agn' file. -> mapping -> @ operator bags.attribs -> bags.attrib calc.newton -> calc.interp clock.dectotm -> clock.totm clock.tmtodec -> clock.todec gethigh -> math.gethigh getlow -> math.getlow io.flush -> io.sync is and si -> if and fi linalg.backsubs -> linalg.gsolve linalg.meq -> linalg.maeq linalg.veq -> linalg.vaeq math.log2exp -> ilog2 math.tworaised -> antilog2 notisnegint -> isnonnegint notisposint -> isnonposint optnnonneg -> optnnonnegative; registers.gettop -> size sethigh -> math.sethigh setlow -> math.setlow stats.kosumdata -> stats.sumdata stats.ssd -> stats.sd utils.cdate -> astro.cdate utils.decode64 -> utils.decodeb64 utils.isleapyear -> astro.isleapyear varprep -> qmdev xbase.field -> xbase.readdbf xbase.isVoid -> xbase.isvoid 2.4.5, March 10, 2015 - Two new modifiers for `strings.format`, `printf`, and related functions have been introduced to prevent quarrels with numerical functions that can return non-numbers in case of errors: 'D' prints an integer if the argument is a number, and the C double representation of undefined otherwise. 'F' likewise either prints a float, or the C double pendant of undefined. - the q modifier to `strings.format`, `printf`, etc. now works as described in the manual. The new Maple-like a modifier works like the q modifier but does not include trailing and leading double quotes. - The new function `strings.diffs` counts the differences between two strings: substitutions, transpositions, deletions, and insertions. Besides returning the number of differences, it can also return the types of differences. The function is thrice as fast as `strings.dleven`, but may count differently. - The name of the former `varprep` operator has been changed to `qmdev`. An alias has been provided for backward-compatibility (put varprep's argument in brackets). - The order of arguments to `stats.sd` has been changed: a) if any third argument is given (formerly second argument), the coefficient of variation is computed. b) if the optional second argument evaluates to `true`, the (unbiased) sample standard deviation is returned, otherwise the population standard deviation is computed. - `stats.var` has been extended to also compute the (unbiased) sample variance or the index of dispersion. - `stats.moment` can now also compute sample moments by passing `true` as the new fourth argument. - `stats.trimean` returned some sort of garbage if the distribution contained less than two observations. This has been fixed. - `stats.ssd` has been deprecated, please use `stats.sd(<distribution>, true)` instead. - Improved error handling of `stats.checkcoordinate`. - The former `gethigh`, `getlow`, `sethigh`, and `setlow` operators are now functions moved into the math library, i.e. the new names are `math.gethigh`, etc. Aliases have been provided for backward compatibility. - Corrected the scheme files. 2.4.4, March 04, 2015 - The new function `descend` recursively descends into a deeply nested structure and returns all elements that satisfy a given condition. - `recurse` now accepts multivariate functions. - `stats.moment` now uses the Kahan-Babuka method to prevent round-off errors. - `stats.kosumdata` has been renamed to `stats.sumdata`. For backward compatibility, an alias has been provided. - Corrected error messages of `stats.acv`. Improved error messages in some other stats functions in case of memory allocation failures. - `stats.iqmean`, `stats.trimean` and `stats.quartile` had to be patched once again to avoid crashes with distributions containing the value `undefined`. 2.4.3, February 18, 2015 - `stats.acf`, `stats.acv`, `stats.ad, `stats.amean`, `stats.ema`, `stats.gini`, `stats.gsm`, `stats.iqmean`, `stats.meanmed`, `stats.sma`, `stats.kosum`, and `stats.zscore` and now use the Kahan-Babushka instead of the Kahan-Ozawa summation algorithm, and thus have become up to 20 percent faster now. Kahan-Babuka adds a corrective value to the pre-computed result after the last iteration, whereas Kahan and Kahan-Ozawa adds it in each iteration. - `stats.prange`, `stats.iqmean`, `stats.trimean`, `stats.quartiles` crashed Agena if an observation contained the value `undefined`. `stats.prange` sometimes also crashed Agena due to other reasons. This has all been fixed. - The `sadd` operator now uses Kahan-Babushka summation to prevent round-off errors. 2.4.2, February 15, 2015 - The new operator `sinc` implements the unnormalised cardinal sine function, i.e. sin(x)/x. - The new function `rect` implements the rectangular function. - The new `linalg.reshape` function restructures a matrix to new dimensions and works like the corresponding Octave function of the same name. - The new function `math.signbit` checks whether its numeric argument has its sign bit set. - The new function `math.eps` returns the relative spacing between its numeric argument and its adjacent number in the machines floating point system. - The new function `stats.iqmean` returns the arithmetic mean of the interquartile range of a distribution. - The new function `stats.trimean` (not to be confused with `stats.trimmean`) returns the trimean and the median of a distribution to check whether it is biased. - Numeric `for` loops with fractional step sizes can now alternatively use the enhanced Kahan-Ozawa summation algorithm instead of the default original Kahan one, by the setting: environ.kernel(kahanozawa = true). - The `copy` operator can now explicitely extract the array or the hash part of a table by passing the new optional second argument 'array' or 'hash'. - `stats.quartiles` has been ported to C and is at least twice as fast now. Furthermore, it no longer assumes a sorted distribution. Also, the function no longer issues an error if the distribution contains less than two observations, but just returns `fail`. - The new `varprep` operator pre-computes a `variance sum` which must be divided either by the number of elements n in a distribution to calculate its population variance, or by n - 1 to compute its sample variance. - `stats.var` and `stats.sd` returned wrong results especially if the variance is close to the arithmetic mean of a distribution; the results sometimes were even negative or had imprecise accuracy. This has been changed by using an algorithm published by Donald Knuth / B. P. Welford, which is much more accurate - to the disadvantage of speed. - All statistics functions that determine or work with quartiles now determine the first and third quartile according to the NIST rule which has always been used by `stats.quartiles` (which had been wrongly documented): position of Q1 := entier(1/4*(n + 1)), position of Q3 := entier(3/4*(n + 1)), where n is the number of observations in a distribution. - `stats.isany` and `stats.isall` crashed with sequences. This has been changed. - Changed the `xbase` sources to prevent compiler warnings. - This release has been Valgrind-checked on x86 Linux and Mac to ensure there are no memory leaks. 2.4.1a, February 03, 2015 - The `lower` and `upper` operators have been tuned by around 6 %. - Applied changes to some source files to reduce compilation problems with GCC >= 4.6. - The Windows version has become around 5 % faster (measured by comparing test suite runs) by recompiling the sources with GCC 4.6.2 and the -O3 switch. - The eCS, Solaris, Windows, Linux, Mac OS X, and DOS versions have been recompiled. - This release has been Valgrind-checked on x86 Linux and Mac to ensure there are no memory leaks. 2.4.1, February 01, 2015 - The new operators `antilog2` and `antilog10` raise 2 and 10 to the power of the given arguments, respectively. Depending on the support of the underlying C functions exp2 and exp10, they are around 30 % faster than the corresponding a^x operations. - The new `signum` operator returns 1 if its real argument is non-negative, and -1 otherwise. For complex argument z, it returns z/|z|. - The new function `math.koadd` adds two numbers using Kahan-Ozawa round-off error prevention. - The new function `stats.peaks` uses an alternative algorithm to determine peaks and valleys in time-series. - The new function `stats.md` returns the median deviation in a distribution. - The new functions `stats.isany` and `stats.isall` check whether distributions contains non-zero elements. - `stats.extrema` now is twice as fast than its former version. - The new function `stats.checkcoordinate` checks whether its argument is a pair consisting of two numbers. - The new function `optnumber` checks whether its argument is a number. If its argument is `null`, it returns a default number. - The new function `optpositive` checks whether its argument is a positive number. If its argument is `null`, it returns a default positive number. Likewise, `optposint` checks for positive integers. - The new function `optnonnegative` checks whether its argument is a non-negative number; if its argument is `null`, it returns a default non-negative number. Likewise, `optnonnegint` checks for positive integers. - The new function `optboolean` checks whether its argument is a Boolean; if its argument is `null`, it returns a default Boolean. - The new function `optstring` checks whether its argument is a string; if its argument is `null`, it returns a default string. - The new function `optcomplex` checks whether its argument is a (complex) number. If its argument is `null`, it returns a default (complex) number. - On Windows, `os.drivestat` returns further information on a drive: total number of clusters, number of free clusters, sectors per cluster, and bytes per sector. - `os.unmount` might have crashed in Solaris. This has been fixed. - `fma`, `isordered`, `trunc`, `log2`, and `isfinite` did not use the underlying C functions if available on the respective platform. Instead they used alternative definitions. This has been fixed. - Minor non-functional changes to the standard library file `lib/library.agn`. - The Agena Quick Reference is now edited with LibreOffice 3.4 instead of OpenOffice 4.1 due to issues with the latter application. - This release has been Valgrind-checked on x86 Linux and Mac to ensure there are no memory leaks. 2.4.0, January 11, 2015 The following measures have been taken to totally hide data in registers: - The `size` operator no longer returns the total size of a register regardless of the setting of the current top pointer. Instead, it simply returns the position of the top pointer at the time of its call. Since now there no longer is a way to determine the actual size of a register, you have to store its original size yourself. This measure also simplifies programming procedures that operate on registers, sequences, and tables. - Agena formerly allowed to assign values above the current top of a register. This bug has been fixed. - Error messages no longer indicate whether data has been hidden (obmission of the `current` word). Other changes are: - Both indices and and index ranges can now be mixed, e.g. a[2 to 3, 2] now is a valid expression. - The following functions now also support registers: `replace`, `join`, `qsadd`, `sadd`, and `smul`, `bintersect`, `bminus`, `bisequal`, `augment`, `columns`, and `utils.writecsv`. - The new function `os.iseCS` determines whether Agena is running on eComStation. - The new function `os.islinux` determines whether Agena is running on Linux. - The new function `os.unmount` unmounts filesystems in the UNIX-based editions. - The new function `getbits` returns all 32 bits in an integer; the new function `setbits` sets the given bits to an integer. - `qsadd` now uses fused-multiply add to compute more accurate results. - The new function `os.terminate` halts, reboots, sleeps, or hibernates the system. It can also logoff or lock the current user session. It is available in the Windows, eCS, and Mac OS X editions. - The new function `os.monitor` puts a monitor on and off, or on stand-by. It is available in the Windows and Linux editions, only. - The new function `os.mouse` returns information on the number of mouse buttons, vertical and horizontal scroll wheels, a flag on whether the left and right buttons have been swapped, and the speed and threshold. It is avail
Source: README.TXT, updated 2016-08-15

Thanks for helping keep SourceForge clean.

Screenshot instructions:
Red Hat Linux   Ubuntu

Click URL instructions:
(This may not be possible with some types of ads)

More information about our ad policies

Briefly describe the problem (required):

Upload screenshot of ad (required):
Select a file, or drag & drop file here.

Please provide the ad click URL, if possible:

Get latest updates about Open Source Projects, Conferences and News.

Sign up for the SourceForge newsletter:

No, thanks


Spanner in the works

But while these tools and practices are intended to improve profitability,
there are indications of a fad-like cycle of over-promising, underperformance
and abandonment of management accounting innovations.

Implementation failure rates for many innovations are high. Even
organisations that initially rate an innovation as successful may change their
view over time and abandon it later.

Some of this fad-like cycling can be explained by behavioural-economic ideas
about how rational human beings try to solve complex problems.

Many management accounting innovations appeal because they promise insights
into organisational complexity. But because they tackle complexity, they are
vulnerable to the side effects of tactics used to simplify complex situations
and the judgment biases that result from them. New tools and practices create
conflict because individuals are subject to overconfidence and ‘false consensus

Some complex systems function adequately, not because they are free of major
errors but because they include countervailing errors.

A major overestimate generated by one element in a faulty budgeting system
can be cancelled out by underestimates elsewhere in the system. The simplifying
tactic of correcting the major over-estimate increases net error in the system.

Innovative systems often provide information that is relevant but highly
uncertain. To simplify, this information is treated as if it were relatively

Processes such as these lead to disappointment with the performance of
innovations. Awareness of these simplifying tactics and their consequences can
make innovations more effective by enabling managers to guard against their
potential side effects.

Joan Luft is professor of accounting at Michigan State University and
editor of the Journal of Management Accounting Research

Related reading

New Logo Saffery Champness


Occup Environ Med 63:244-249 doi:10.1136/oem.2005.020644
  • Original article

  1. T Nakadate1,
  2. Y Yamano1,
  3. C Adachi1,
  4. Y Kikuchi2,
  5. Y Nishiwaki2,
  6. M Nohara3,
  7. T Satoh4,
  8. K Omae2
  1. 1Showa University School of Medicine, Tokyo, Japan
  2. 2Keio University School of Medicine, Tokyo, Japan
  3. 3Tokyo Women’s Medical University School of Medicine, Tokyo, Japan
  4. 4Kitasato University School of Medicine, Sagamihara, Japan
  1. Correspondence to:
 Professor T Nakadate
 Department of Hygiene, Showa University School of Medicine, 1-5-8 Hatanodai, Shinagawa-ku, Tokyo 142-8555, Japan; nakadate{at}
  • Accepted 27 October 2005

Objectives: To conduct a cross sectional study to evaluate the association between the biological indices of lung fibrosis and toner dust exposure in an occupational cohort handling solid toner dust in their work life.

Methods: A total of 600 male toner workers and 212 control subjects were surveyed in terms of their subjective respiratory symptoms, pulmonary functions, and chest radiographic findings. In addition to the exposure history, the current working conditions and personal exposure levels to toner dust were also examined.

Results: Although subjects handling toner for more than 20 years tended to show a higher prevalence of respiratory symptoms and minimal chest x ray abnormalities, there was no consistent relation between the exposure to toner dust and the biological responses of the respiratory system.

Conclusion: Deterioration of respiratory health related to toner dust exposure is less likely to occur in current well controlled work environments, especially if the powdered toner is handled carefully. Nonetheless, it is important to collect further epidemiological evidence on the biological effects of toner dust inhalation, preferably using a longitudinal study design.

  • Competing interests: none.


Change search
ReferencesLink to record
Permanent link

Direct link
Reading Success and Vocabulary Knowledge among advanced professionals with English as their second language (L2): A comparative study of Russian and Swedish medical professionals in Sweden
Stockholm University, Faculty of Humanities, Department of English.
2009 (English)Independent thesis Basic level (degree of Bachelor), 80 credits / 120 HE creditsStudent thesis
Abstract [en]

It is vital you have advanced knowledge in English as a second language (L2) if you work and/or research as a medical specialist at the Swedish academic university hospitals in Sweden. Otherwise it will be impossible to communicate within your area of interest, either orally or in writing, or even by means of reading, not only internationally but also between co-workers. All communication between academic professionals from different countries as well as textbooks, articles, instructions, lectures and exchange of information are in English.

Interviews and tests for this essay were made with advanced medical researchers and specialists at Karolinska Institutet and Karolinska University Hospital in Stockholm, Sweden.

The aim of this research is to find out how closely estimated vocabulary size is related to successful reading.

There has not been much research on advanced academic intellectuals when it comes to advanced reading comprehension. Some studies on children and younger adults have shown that reading proficiency is based on the size of their vocabulary, the bigger vocabulary they have the higher their reading proficiency, while other studies have shown that the more they read the more they understand and automatically their vocabulary increases. Are these the only reasons for their reading proficiency, or are there other aspects involved? Do their vocabulary sizes affect their understanding when they read? Or what other reasons help reading and comprehending the text?

In comparing readers’ understanding of different domain-specific texts, it can be hypothesized that there are differences in comprehension between general and more specialized texts. It can also be thought that it is easier for Swedes to read and comprehend English as the same alphabet is used in English and Swedish, than for Russians, who are used to a different language structure with other typographical factors.

Factors that Can Affect Reading Success

- The Linguistic Threshold Hypothesis

- Background knowledge

- Prior knowledge

- Interest and attitude

General Questions

1. How important is a L2 reader’s vocabulary size to his/her understanding of a text? Could other factors be more important?

2. Is it possible for professionals with poor linguistic proficiency in English to read and understand domain specific texts due to their expert knowledge?

3. Is professionals’ receptive proficiency similar within their domain specific areas and in general areas?

4. Is there an effect of having lived in an English-speaking country on reading comprehension or vocabulary size?

1. The L1 typology would make a difference.

2. The Swedes would have a better vocabulary and a better general comprehension of general English, and thereby a better understanding of the domain-specific texts as well.

Professionals often have English as their L2. They are assumed to read English texts as efficiently as they read texts in their L1. In this essay the focus was set on their reading ability and their vocabulary knowledge. Vocabulary was assessed as academic or infrequent, and reading was assessed by means of tests of word recognition, single sentence comprehension, evaluation of logical arguments based on two sentence recognitions, and reading domain-specific, medical articles as well as general articles.

Data was collected from medical researchers and specialists during this empirical research. The specialists were presumed to read English journal articles on a daily basis in their area of expertise, medicine, and use English as their working language. Seven Russians and seven Swedes were interviewed between February and April 2007. They had chosen the date, time and place for their interviews.

The testing took about 90 minutes and was divided into

Each subject was asked to fill out a questionnaire about his/her educational and social background. This data could not be used in this essay, but would be interesting to use for research about the impact of social background on the proficiency of English as a L2.

Then they were asked to continue with paper diagnostic tests, the Proficiency Test, testing their syntax skills and vocabulary size. The Proficiency Test is a part of DIALANG, a self-assessment test developed by the Project of the European Commission for use on the Internet, and it was used along with a test of academic vocabulary, and a test of infrequent vocabulary, divided into synonyms and antonyms.

The computerized test, the SuperLab test, was divided into two sections. For the first section, Reading Proficiency, articles within the medical domain as well as various general domains were read and then retold orally. The retold stories were taped and the language used when retelling the story, L1 or L2, was decided by the subject, so they would feel comfortable when speaking. These interviews were transcribed and analyzed. The second part of the computerized sub skills, Reading Comprehension, consisted of word recognition and reading comprehension of one and more sentences.

The Proficiency Test

The Proficiency test tested vocabulary knowledge. Overall most of the subjects thought Part 2 Synonyms and Part 3 Antonyms were the most difficult parts of the whole test. Although they knew other languages, it was not possible to use that knowledge in this part of the test. One Swede thought the Part 3 Antonyms was the most difficult. Some words were recognised from earlier, from looking them up in dictionaries several times and then forgetting them again. Sometimes no alternative seemed to be correct. Another Swede commented that it was not obvious which alternative was the correct answer. Sometimes the synonym or antonym could be explained in his own words, but not with any of the alternatives. A third Swede commented that in reading a regular text you do not have to know every single word to get coherence.

The SuperLab Test

The computerized reading test, the SuperLab test, was to show reading comprehension of texts, sentences and word recognition. Since sentence comprehension did not correlate well with vocabulary size here, these results suggest that the size of the vocabulary above a certain level does not have an immediate impact on the logical judgement or comprehension of sentences At the same time it has to be remembered that the subjects are advanced academic professionals, and might not only use their vocabulary knowledge and size in a L2 when it comes to making conclusions and decisions.

Reading Comprehension - Analysis

The Reading Comprehension part of the test consisted of six different texts: three general texts and three medical texts. For each text there were a number of propositions that had to be correctly recalled to get points. The first text was on paper and the last five read and timed on the computer. It has to be kept in mind that the text read on paper, Text 1, presented the subjects with an opportunity to read as they usually do. Most of them seemed to read the title, skimmed the text and then read and reread the interesting or missed parts several times, until the message was clear. When the other five texts were read on the computer screen on the other hand, only one sentence was shown at a time, and disappeared when the next sentence was keyed for. This computerized way of reading the text forced the reader to remember what was read after each sentence, without knowing what came next. So, the ordinary way of reading a text was changed.

Reading Comprehension - Results

A conclusion of all propositions indicated that the Russians as a group had higher results than the Swedes. When looking at the individual answers a pattern can be shown. The Swedes on an average were a more homogenous group with a smaller span between the top result and the lowest. The Russians were a more heterogeneous group.

In this essay the focus has been on the reading quality. The results showed that there are other circumstances than simple language and reading proficiency to be aware of. There is a difference in their background knowledge. How much of their ‘recall’ do they actually remember from the text and how much do they know from beforehand?

For example, the Reading Comprehension Test with the retelling of the five texts read in an unnatural way did not only test how much the subjects understood and recalled, but also how much they remembered. While reading the texts on the computer, one sentence at a time, the subjects had to focus on the meaning of each sentence in the text, memorize it and then read the next sentence. For the three first texts there was no demand for any previous knowledge to be able to read and understand the words and sentences separately. The subjects did not use any dictionaries, which they seldom do in their ordinary, everyday work either.

The results also show that interest and background knowledge were important factors to be able to understand the whole contents of each text. The meaning of the text was more easily understood the more background knowledge the subjects had.

Hypothesis 1 - The L1 typology would make a difference.

The tests did not show that the language background made a difference. The Russians lived in Sweden and spoke Russian among themselves but English with everybody else. They were well-educated academics, not only proficient in English within their own area, medical texts, but also very good at understanding general texts. When it came to reading comprehension the background knowledge seemed to be more important than the vocabulary skills.

It was not indicated at any time during the research for this essay that the Swedes had a better vocabulary and thereby would understand both general and domain-specific texts better. The understanding and comprehension seemed to be more based on attitude and background knowledge of the different texts.

Tsui and Fullilove (1998) found in their studies that it was extremely difficult to process information which contradicted what they already knew. This particularly showed during this essay, with some of the Russians questioning and discussing the contents of the medical texts, exactly as Steffensen and Joag-Dev (1979) found in their study. The authors stated that readers seemed to dismiss information they found unimportant, add information they thought should be there, and focus on what they found important, all based on their world view and their opinion.

Most of the Russians seemed to be more involved and questioning than the Swedes in this investigation. This study showed that the more background knowledge the subjects had, the more they understood the texts.

During the testing he Swedes made a point of the difficulties of reading the texts on the computers, which did not agree with their reading strategies. These Swedes seemed to attempt to use more normal strategies when reading the texts on the computer screen than the Russians. The Russians appeared to read more slowly overall. Slow readers usually had difficulties putting things together towards the end of sentences and paragraphs. Probably the Russians used more background information than English reading proficiency and understanding when doing the test.

Vocabulary Size and Reading Success

During the work with this essay it was not proven that vocabulary size was directly linked to reading proficiency. The readers tested were advanced academic professionals, and might not only use their vocabulary but also their background knowledge when understanding the content of the texts used. The Russians were not a random selection, because those who participated were more confident with their English knowledge than those that did not participate.

There were of course some limitations during this study. One was fatigue among the subjects due to their hectic working environment and the long duration of the tests. Another issue was that most of the texts were on the screen, to be read sentence by sentence, and hence unnaturally read.

Out of the results of these tests the conclusion could be drawn that even if you have a larger vocabulary, it would not necessarily mean you understand more.

After having worked with the material for this essay and interviewing the scientists, brought up in an academic environment, I came to the conclusion that vocabulary knowledge and reading skills shown during a test did not show everything. Speed and accuracy of reading often correlate, but that was not the case in this study. Low proficiency did not seem to make an impact on the understanding of the text. The background knowledge was very important, but at the same time the attitude and interest of the subjects during the testing also had an enormous impact on their results.

Steffensen, M.S., Joag-Dev, C. and Anderson, R.C. 1979. A cross-cultural perspective on reading comprehension. Reading Research Quarterly, Vol. 15, No. 1 (pp. 10-29).

Tsui, A.B.M. and Fullilove, J. 1998 Bottom-up or top-down processing as a discriminator of L2 listening performance. Ap

Place, publisher, year, edition, pages
2009. , 25 p.
Keyword [en]
successful reading, vocabulary size, advanced reading comprehension, second language, English, domain-specific text, academic professionals, background knowledge, prior knowledge, interest, attitude, the linguistic threshold hypothesis
National Category
General Language Studies and Linguistics
URN: urn:nbn:se:su:diva-8711OAI: diva2:175228
2008-06-14, 00:00 (English)
Humanities, Theology
Available from: 2009-08-11 Created: 2004-01-01 Last updated: 2009-08-11Bibliographically approved

Open Access in DiVA

No full text

By organisation
Department of English
General Language Studies and Linguistics

Search outside of DiVA

GoogleGoogle Scholar

Total: 50 hits
ReferencesLink to record
Permanent link

Direct link


John Lithgow
f p @
67 lists

John Lithgow

John Arthur Lithgow is an American actor, musician, and author. Lithgow has received acclaim and many accolades in his career including two Tony Awards, five Emmy Awards, two Golden Globe Awards, two Screen Actors Guild Awards, an American Comedy Award, four Drama Desk Awards and was also nominated for two Academy Awards and four Grammy Awards. Lithgow was inducted into the Hollywood Walk of Fame and American Theater Hall of Fame. Lithgow is well known for his telev...

... more on Wikipedia

lists about John Lithgow

  • The Best John Lithgow Movies

    605 Votes

    List of the best John Lithgow movies, ranked best to worst with movie trailers when available. John Lithgow's highest grossing movies have received a lot of accolades over the years, earning more

John Lithgow is ranked on...

John Lithgow is also found on...