Go to the first, previous, next, last section, table of contents.
Most users of g77
can be divided into two camps:
g77
.
g77
to compile existing, "legacy" code.
Users writing new code generally understand most of the necessary
aspects of Fortran to write "mainstream" code, but often need
help deciding how to handle problems, such as the construction
of libraries containing BLOCK DATA
.
Users dealing with "legacy" code sometimes don't have much
experience with Fortran, but believe that the code they're compiling
already works when compiled by other compilers (and might
not understand why, as is sometimes the case, it doesn't work
when compiled by g77
).
The following information is designed to help users do a better job coping with existing, "legacy" Fortran code, and with writing new code as well.
f2c
is so great, why g77
?
g77
solves a common problem.
DO
loops surprise many people.
Without f2c
, g77
would have taken much longer to
do and probably not been as good for quite a while.
Sometimes people who notice how much g77
depends on, and
documents encouragement to use, f2c
ask why g77
was created if f2c
already existed.
This section gives some basic answers to these questions, though it is not intended to be comprehensive.
g77
offers several extensions to FORTRAN 77 language that f2c
doesn't:
CYCLE
and EXIT
SELECT CASE
KIND=
and LEN=
notation
FORMAT
statements
(such as `FORMAT(I<J>)',
where `J' is a PARAMETER
named constant)
MvBits
intrinsic
libU77
(Unix-compatibility) library,
with routines known to compiler as intrinsics
(so they work even when compiler options are used
to change the interfaces used by Fortran routines)
g77
also implements iterative DO
loops
so that they work even in the presence of certain "extreme" inputs,
unlike f2c
.
See section Loops.
However, f2c
offers a few that g77
doesn't, such as:
PARAMETER
statements
AUTOMATIC
statement
It is expected that g77
will offer some or all of these missing
features at some time in the future.
g77
offers better diagnosis of problems in FORMAT
statements.
f2c
doesn't, for example, emit any diagnostic for
`FORMAT(XZFAJG10324)',
leaving that to be diagnosed, at run time, by
the libf2c
run-time library.
g77
offers compiler options that f2c
doesn't,
most of which are designed to more easily accommodate
legacy code:
However, f2c
offers a few that g77
doesn't,
like an option to have REAL
default to REAL*8
.
It is expected that g77
will offer all of the
missing options pertinent to being a Fortran compiler
at some time in the future.
Saving the steps of writing and then rereading C code is a big reason
why g77
should be able to compile code much faster than using
f2c
in conjunction with the equivalent invocation of gcc
.
However, due to g77
's youth, lots of self-checking is still being
performed.
As a result, this improvement is as yet unrealized
(though the potential seems to be there for quite a big speedup
in the future).
It is possible that, as of version 0.5.18, g77
is noticeably faster compiling many Fortran source files than using
f2c
in conjunction with gcc
.
g77
has the potential to better optimize code than f2c
,
even when gcc
is used to compile the output of f2c
,
because f2c
must necessarily
translate Fortran into a somewhat lower-level language (C) that cannot
preserve all the information that is potentially useful for optimization,
while g77
can gather, preserve, and transmit that information directly
to the GBE.
For example, g77
implements ASSIGN
and assigned
GOTO
using direct assignment of pointers to labels and direct
jumps to labels, whereas f2c
maps the assigned labels to
integer values and then uses a C switch
statement to encode
the assigned GOTO
statements.
However, as is typical, theory and reality don't quite match, at least
not in all cases, so it is still the case that f2c
plus gcc
can generate code that is faster than g77
.
Version 0.5.18 of g77
offered default
settings and options, via patches to the gcc
back end, that allow for better program speed, though
some of these improvements also affected the performance
of programs translated by f2c
and then compiled
by g77
's version of gcc
.
Version 0.5.20 of g77
offers further performance
improvements, at least one of which (alias analysis) is
not generally applicable to f2c
(though f2c
could presumably be changed to also take advantage of
this new capability of the gcc
back end, assuming
this is made available in an upcoming release of gcc
).
Because g77
compiles directly to assembler code like gcc
,
instead of translating to an intermediate language (C) as does f2c
,
support for debugging can be better for g77
than f2c
.
However, although g77
might be somewhat more "native" in terms of
debugging support than f2c
plus gcc
, there still are a lot
of things "not quite right".
Many of the important ones should be resolved in the near future.
For example, g77
doesn't have to worry about reserved names
like f2c
does.
Given `FOR = WHILE', f2c
must necessarily
translate this to something other than
`for = while;', because C reserves those words.
However, g77
does still uses things like an extra level of indirection
for ENTRY
-laden procedures--in this case, because the back end doesn't
yet support multiple entry points.
Another example is that, given
COMMON A, B EQUIVALENCE (B, C)
the g77
user should be able to access the variables directly, by name,
without having to traverse C-like structures and unions, while f2c
is unlikely to ever offer this ability (due to limitations in the
C language).
However, due to apparent bugs in the back end, g77
currently doesn't
take advantage of this facility at all--it doesn't emit any debugging
information for COMMON
and EQUIVALENCE
areas,
other than information
on the array of char
it creates (and, in the case
of local EQUIVALENCE
, names) for each such area.
Yet another example is arrays.
g77
represents them to the debugger
using the same "dimensionality" as in the source code, while f2c
must necessarily convert them all to one-dimensional arrays to fit
into the confines of the C language.
However, the level of support
offered by debuggers for interactive Fortran-style access to arrays
as compiled by g77
can vary widely.
In some cases, it can actually
be an advantage that f2c
converts everything to widely supported
C semantics.
In fairness, g77
could do many of the things f2c
does
to get things working at least as well as f2c
---for now,
the developers prefer making g77
work the
way they think it is supposed to, and finding help improving the
other products (the back end of gcc
; gdb
; and so on)
to get things working properly.
To avoid the extensive hassle that would be needed to avoid this,
f2c
uses C character constants to encode character and Hollerith
constants.
That means a constant like `'HELLO'' is translated to
`"hello"' in C, which further means that an extra null byte is
present at the end of the constant.
This null byte is superfluous.
g77
does not generate such null bytes.
This represents significant
savings of resources, such as on systems where `/dev/null' or
`/dev/zero' represent bottlenecks in the systems' performance,
because g77
simply asks for fewer zeros from the operating
system than f2c
.
(Avoiding spurious use of zero bytes, each byte typically have
eight zero bits, also reduces the liabilities in case
Microsoft's rumored patent on the digits 0 and 1 is upheld.)
To ensure that block data program units are linked, especially a concern
when they are put into libraries, give each one a name (as in
`BLOCK DATA FOO') and make sure there is an `EXTERNAL FOO'
statement in every program unit that uses any common block
initialized by the corresponding BLOCK DATA
.
g77
currently compiles a BLOCK DATA
as if it were a
SUBROUTINE
,
that is, it generates an actual procedure having the appropriate name.
The procedure does nothing but return immediately if it happens to be
called.
For `EXTERNAL FOO', where `FOO' is not otherwise referenced in the
same program unit, g77
assumes there exists a `BLOCK DATA FOO'
in the program and ensures that by generating a
reference to it so the linker will make sure it is present.
(Specifically, g77
outputs in the data section a static pointer to the
external name `FOO'.)
The implementation g77
currently uses to make this work is
one of the few things not compatible with f2c
as currently
shipped.
f2c
currently does nothing with `EXTERNAL FOO' except
issue a warning that `FOO' is not otherwise referenced,
and, for `BLOCK DATA FOO',
f2c
doesn't generate a dummy procedure with the name `FOO'.
The upshot is that you shouldn't mix f2c
and g77
in
this particular case.
If you use f2c
to compile `BLOCK DATA FOO',
then any g77
-compiled program unit that says `EXTERNAL FOO'
will result in an unresolved reference when linked.
If you do the
opposite, then `FOO' might not be linked in under various
circumstances (such as when `FOO' is in a library, or you're
using a "clever" linker--so clever, it produces a broken program
with little or no warning by omitting initializations of global data
because they are contained in unreferenced procedures).
The changes you make to your code to make g77
handle this situation,
however, appear to be a widely portable way to handle it.
That is, many systems permit it (as they should, since the
FORTRAN 77 standard permits `EXTERNAL FOO' when `FOO'
is a block data program unit), and of the ones
that might not link `BLOCK DATA FOO' under some circumstances, most of
them appear to do so once `EXTERNAL FOO' is present in the appropriate
program units.
Here is the recommended approach to modifying a program containing a program unit such as the following:
BLOCK DATA FOO COMMON /VARS/ X, Y, Z DATA X, Y, Z / 3., 4., 5. / END
If the above program unit might be placed in a library module, then
ensure that every program unit in every program that references that
particular COMMON
area uses the EXTERNAL
statement
to force the area to be initialized.
For example, change a program unit that starts with
INTEGER FUNCTION CURX() COMMON /VARS/ X, Y, Z CURX = X END
so that it uses the EXTERNAL
statement, as in:
INTEGER FUNCTION CURX() COMMON /VARS/ X, Y, Z EXTERNAL FOO CURX = X END
That way, `CURX' is compiled by g77
(and many other
compilers) so that the linker knows it must include `FOO',
the BLOCK DATA
program unit that sets the initial values
for the variables in `VAR', in the executable program.
The meaning of a DO
loop in Fortran is precisely specified
in the Fortran standard...and is quite different from what
many programmers might expect.
In particular, Fortran iterative DO
loops are implemented as if
the number of trips through the loop is calculated before
the loop is entered.
The number of trips for a loop is calculated from the start, end, and increment values specified in a statement such as:
DO iter = start, end, increment
The trip count is evaluated using a fairly simple formula based on the three values following the `=' in the statement, and it is that trip count that is effectively decremented during each iteration of the loop. If, at the beginning of an iteration of the loop, the trip count is zero or negative, the loop terminates. The per-loop-iteration modifications to iter are not related to determining whether to terminate the loop.
There are two important things to remember about the trip count:
INTEGER(KIND=1)
.
These two items mean that there are loops that cannot
be written in straightforward fashion using the Fortran DO
.
For example, on a system with the canonical 32-bit two's-complement
implementation of INTEGER(KIND=1)
, the following loop will not work:
DO I = -2000000000,<PHONE_NUMBER>
Although the start and end values are well within
the range of INTEGER(KIND=1)
, the trip count is not.
The expected trip count is<PHONE_NUMBER>1, which is outside
the range of INTEGER(KIND=1)
on many systems.
Instead, the above loop should be constructed this way:
I = -2000000000 DO IF (I .GT.<PHONE_NUMBER>) EXIT ... I = I + 1 END DO
The simple DO
construct and the EXIT
statement
(used to leave the innermost loop)
are F90 features that g77
supports.
Some Fortran compilers have buggy implementations of DO
,
in that they don't follow the standard.
They implement DO
as a straightforward translation
to what, in C, would be a for
statement.
Instead of creating a temporary variable to hold the trip count
as calculated at run time, these compilers
use the iteration variable iter to control
whether the loop continues at each iteration.
The bug in such an implementation shows up when the trip count is within the range of the type of iter, but the magnitude of `ABS(end) + ABS(incr)' exceeds that range. For example:
DO I =<PHONE_NUMBER>,<PHONE_NUMBER>
A loop started by the above statement will work as implemented
by g77
, but the use, by some compilers, of a
more C-like implementation akin to
for (i =<PHONE_NUMBER>; i <=<PHONE_NUMBER>; ++i)
produces a loop that does not terminate, because `i' can never be greater than<PHONE_NUMBER>, since incrementing it beyond that value overflows `i', setting it to -2147483648. This is a large, negative number that still is less than<PHONE_NUMBER>.
Another example of unexpected behavior of DO
involves
using a nonintegral iteration variable iter, that is,
a REAL
variable.
Consider the following program:
DATA BEGIN, END, STEP /.1, .31, .007/ DO 10 R = BEGIN, END, STEP IF (R .GT. END) PRINT *, R, ' .GT. ', END, '!!' PRINT *,R 10 CONTINUE PRINT *,'LAST = ',R IF (R .LE. END) PRINT *, R, ' .LE. ', END, '!!' END
A C-like view of DO
would hold that the two "exclamatory"
PRINT
statements are never executed.
However, this is the output of running the above program
as compiled by g77
on a GNU/Linux ix86 system:
.100000001 .107000001 .114 .120999999 ... .289000005 .296000004 .303000003 LAST = .310000002 .310000002 .LE. .310000002!!
Note that one of the two checks in the program turned up
an apparent violation of the programmer's expectation--yet,
the loop is correctly implemented by g77
, in that
it has 30 iterations.
This trip count of 30 is correct when evaluated using
the floating-point representations for the begin,
end, and incr values (.1, .31, .007) on GNU/Linux
ix86 are used.
On other systems, an apparently more accurate trip count
of 31 might result, but, nevertheless, g77
is
faithfully following the Fortran standard, and the result
is not what the author of the sample program above
apparently expected.
(Such other systems might, for different values in the DATA
statement, violate the other programmer's expectation,
for example.)
Due to this combination of imprecise representation
of floating-point values and the often-misunderstood
interpretation of DO
by standard-conforming
compilers such as g77
, use of DO
loops
with REAL
iteration
variables is not recommended.
Such use can be caught by specifying `-Wsurprising'.
See section Options to Request or Suppress Warnings, for more information on this
option.
Getting Fortran programs to work in the first place can be quite a challenge--even when the programs already work on other systems, or when using other compilers.
g77
offers some facilities that might be useful for
tracking down bugs in such programs.
A fruitful source of bugs in Fortran source code is use, or mis-use, of Fortran's implicit-typing feature, whereby the type of a variable, array, or function is determined by the first character of its name.
Simple cases of this include statements like `LOGX=9.227',
without a statement such as `REAL LOGX'.
In this case, `LOGX' is implicitly given INTEGER(KIND=1)
type, with the result of the assignment being that it is given
the value `9'.
More involved cases include a function that is defined starting
with a statement like `DOUBLE PRECISION FUNCTION IPS(...)'.
Any caller of this function that does not also declare `IPS'
as type DOUBLE PRECISION
(or, in GNU Fortran, REAL(KIND=2)
)
is likely to assume it returns
INTEGER
, or some other type, leading to invalid results
or even program crashes.
The `-Wimplicit' option might catch failures to properly specify the types of variables, arrays, and functions in the code.
However, in code that makes heavy use of Fortran's
implicit-typing facility, this option might produce so
many warnings about cases that are working, it would be
hard to find the one or two that represent bugs.
This is why so many experienced Fortran programmers strongly
recommend widespread use of the IMPLICIT NONE
statement,
despite it not being standard FORTRAN 77, to completely turn
off implicit typing.
(g77
supports IMPLICIT NONE
, as do almost all
FORTRAN 77 compilers.)
Note that `-Wimplicit' catches only implicit typing of names. It does not catch implicit typing of expressions such as `X**(2/3)'. Such expressions can be buggy as well--in fact, `X**(2/3)' is equivalent to `X**0', due to the way Fortran expressions are given types and then evaluated. (In this particular case, the programmer probably wanted `X**(2./3.)'.)
Many Fortran programs were developed on systems that provided automatic initialization of all, or some, variables and arrays to zero. As a result, many of these programs depend, sometimes inadvertently, on this behavior, though to do so violates the Fortran standards.
You can ask g77
for this behavior by specifying the
`-finit-local-zero' option when compiling Fortran code.
(You might want to specify `-fno-automatic' as well,
to avoid code-size inflation for non-optimized compilations.)
Note that a program that works better when compiled with the
`-finit-local-zero' option
is almost certainly depending on a particular system's,
or compiler's, tendency to initialize some variables to zero.
It might be worthwhile finding such cases and fixing them,
using techniques such as compiling with the `-O -Wuninitialized'
options using g77
.
Many Fortran programs were developed on systems that
saved the values of all, or some, variables and arrays
across procedure calls.
As a result, many of these programs depend, sometimes
inadvertently, on being able to assign a value to a
variable, perform a RETURN
to a calling procedure,
and, upon subsequent invocation, reference the previously
assigned variable to obtain the value.
They expect this despite not using the SAVE
statement
to specify that the value in a variable is expected to survive
procedure returns and calls.
Depending on variables and arrays to retain values across
procedure calls without using SAVE
to require it violates
the Fortran standards.
You can ask g77
to assume SAVE
is specified for all
relevant (local) variables and arrays by using the
`-fno-automatic' option.
Note that a program that works better when compiled with the
`-fno-automatic' option
is almost certainly depending on not having to use
the SAVE
statement as required by the Fortran standard.
It might be worthwhile finding such cases and fixing them,
using techniques such as compiling with the `-O -Wuninitialized'
options using g77
.
The `-Wunused' option can find bugs involving implicit typing, sometimes more easily than using `-Wimplicit' in code that makes heavy use of implicit typing. An unused variable or array might indicate that the spelling for its declaration is different from that of its intended uses.
Other than cases involving typos, unused variables rarely indicate actual bugs in a program. However, investigating such cases thoroughly has, on occasion, led to the discovery of code that had not been completely written--where the programmer wrote declarations as needed for the whole algorithm, wrote some or even most of the code for that algorithm, then got distracted and forgot that the job was not complete.
As with unused variables, It is possible that unused arguments to a procedure might indicate a bug. Compile with `-W -Wunused' option to catch cases of unused arguments.
Note that `-W' also enables warnings regarding overflow of floating-point constants under certain circumstances.
The `-Wsurprising' option can help find bugs involving
expression evaluation or in
the way DO
loops with non-integral iteration variables
are handled.
Cases found by this option might indicate a difference of
interpretation between the author of the code involved, and
a standard-conforming compiler such as g77
.
Such a difference might produce actual bugs.
In any case, changing the code to explicitly do what the
programmer might have expected it to do, so g77
and
other compilers are more likely to follow the programmer's
expectations, might be worthwhile, especially if such changes
make the program work better.
The `-falias-check', `-fargument-alias',
`-fargument-noalias',
and `-fno-argument-noalias-global' options,
introduced in version 0.5.20 and
g77
's version <IP_ADDRESS>.f.2 of gcc
,
were withdrawn as of g77
version 0.5.23
due to their not being supported by gcc
version 2.8.
These options, which control the assumptions regarding aliasing
(overlapping) of writes and reads to main memory (core) made
by the gcc
back end,
might well be added back (in some form) in a future version
of gcc
.
However, these options are supported by egcs
.
The information below still is useful, but applies to
only those versions of g77
that support the
alias analysis implied by support for these options.
These options are effective only when compiling with `-O' (specifying any level other than `-O0') or with `-falias-check'.
The default for Fortran code is `-fargument-noalias-global'.
(The default for C code and code written in other C-based languages
is `-fargument-alias'.
These defaults apply regardless of whether you use g77
or
gcc
to compile your code.)
Note that, on some systems, compiling with `-fforce-addr' in effect can produce more optimal code when the default aliasing options are in effect (and when optimization is enabled).
If your program is not working when compiled with optimization,
it is possible it is violating the Fortran standards (77 and 90)
by relying on the ability to "safely" modify variables and
arrays that are aliased, via procedure calls, to other variables
and arrays, without using EQUIVALENCE
to explicitly
set up this kind of aliasing.
(The FORTRAN 77 standard's prohibition of this sort of
overlap, generally referred to therein as "storage
assocation", appears in Sections <IP_ADDRESS>.
This prohibition allows implementations, such as g77
,
to, for example, implement the passing of procedures and
even values in COMMON
via copy operations into local,
perhaps more efficiently accessed temporaries at entry to a
procedure, and, where appropriate, via copy operations back
out to their original locations in memory at exit from that
procedure, without having to take into consideration the
order in which the local copies are updated by the code,
among other things.)
To test this hypothesis, try compiling your program with
the `-fargument-alias' option, which causes the
compiler to revert to assumptions essentially the same as
made by versions of g77
prior to 0.5.20.
If the program works using this option, that strongly suggests
that the bug is in your program.
Finding and fixing the bug(s) should result in a program that
is more standard-conforming and that can be compiled by g77
in a way that results in a faster executable.
(You might want to try compiling with `-fargument-noalias',
a kind of half-way point, to see if the problem is limited to
aliasing between dummy arguments and COMMON
variables--this
option assumes that such aliasing is not done, while still allowing
aliasing among dummy arguments.)
An example of aliasing that is invalid according to the standards is shown in the following program, which might not produce the expected results when executed:
I = 1 CALL FOO(I, I) PRINT *, I END SUBROUTINE FOO(J, K) J = J + K K = J * K PRINT *, J, K END
The above program attempts to use the temporary aliasing of the `J' and `K' arguments in `FOO' to effect a pathological behavior--the simultaneous changing of the values of both `J' and `K' when either one of them is written.
The programmer likely expects the program to print these values:
2 4 4
However, since the program is not standard-conforming, an implementation's behavior when running it is undefined, because subroutine `FOO' modifies at least one of the arguments, and they are aliased with each other. (Even if one of the assignment statements was deleted, the program would still violate these rules. This kind of on-the-fly aliasing is permitted by the standard only when none of the aliased items are defined, or written, while the aliasing is in effect.)
As a practical example, an optimizing compiler might schedule the `J =' part of the second line of `FOO' after the reading of `J' and `K' for the `J * K' expression, resulting in the following output:
2 2 2
Essentially, compilers are promised (by the standard and, therefore,
by programmers who write code they claim to be standard-conforming)
that if they cannot detect aliasing via static analysis of a single
program unit's EQUIVALENCE
and COMMON
statements, no
such aliasing exists.
In such cases, compilers are free to assume that an assignment to
one variable will not change the value of another variable, allowing
it to avoid generating code to re-read the value of the other
variable, to re-schedule reads and writes, and so on, to produce
a faster executable.
The same promise holds true for arrays (as seen by the called
procedure)---an element of one dummy array cannot be aliased
with, or overlap, any element of another dummy array or be
in a COMMON
area known to the procedure.
(These restrictions apply only when the procedure defines, or writes to, one of the aliased variables or arrays.)
Unfortunately, there is no way to find all possible cases of violations of the prohibitions against aliasing in Fortran code. Static analysis is certainly imperfect, as is run-time analysis, since neither can catch all violations. (Static analysis can catch all likely violations, and some that might never actually happen, while run-time analysis can catch only those violations that actually happen during a particular run. Neither approach can cope with programs mixing Fortran code with routines written in other languages, however.)
Currently, g77
provides neither static nor run-time facilities
to detect any cases of this problem, although other products might.
Run-time facilities are more likely to be offered by future
versions of g77
, though patches improving g77
so that
it provides either form of detection are welcome.
For several versions prior to 0.5.20, g77
configured its
version of the libf2c
run-time library so that one of
its configuration macros, ALWAYS_FLUSH
, was defined.
This was done as a result of a belief that many programs expected
output to be flushed to the operating system (under UNIX, via
the fflush()
library call) with the result that errors,
such as disk full, would be immediately flagged via the
relevant ERR=
and IOSTAT=
mechanism.
Because of the adverse effects this approach had on the performance
of many programs, g77
no longer configures libf2c
(now named libg2c
in its g77
incarnation)
to always flush output.
If your program depends on this behavior, either insert the
appropriate `CALL FLUSH' statements, or modify the sources
to the libg2c
, rebuild and reinstall g77
, and
relink your programs with the modified library.
(Ideally, libg2c
would offer the choice at run-time, so
that a compile-time option to g77
or f2c
could
result in generating the appropriate calls to flushing or
non-flushing library routines.)
See section Always Flush Output, for information on how to modify
the g77
source tree so that a version of libg2c
can be built and installed with the ALWAYS_FLUSH
macro defined.
If your program crashes at run time with a message including
the text `illegal unit number', that probably is
a message from the run-time library, libg2c
.
The message means that your program has attempted to use a
file unit number that is out of the range accepted by
libg2c
.
Normally, this range is 0 through 99, and the high end
of the range is controlled by a libg2c
source-file
macro named MXUNIT
.
If you can easily change your program to use unit numbers in the range 0 through 99, you should do so.
Otherwise, see section Larger File Unit Numbers, for information on how
to change MXUNIT
in libg2c
so you can build and
install a new version of libg2c
that supports the larger
unit numbers you need.
Note: While libg2c
places a limit on the range
of Fortran file-unit numbers, the underlying library and operating
system might impose different kinds of limits.
For example, some systems limit the number of files simultaneously
open by a running program.
Information on how to increase these limits should be found
in your system's documentation.
If your program depends on exact IEEE 754 floating-point handling it may help on some systems--specifically x86 or m68k hardware--to use the `-ffloat-store' option or to reset the precision flag on the floating-point unit. See section Options That Control Optimization.
However, it might be better simply to put the FPU into double precision
mode and not take the performance hit of `-ffloat-store'. On x86
and m68k GNU systems you can do this with a technique similar to that
for turning on floating-point exceptions
(see section Floating-point Exception Handling).
The control word could be set to double precision by
replacing the __setfpucw
call with one like this:
__setfpucw ((_FPU_DEFAULT & ~_FPU_EXTENDED) | _FPU_DOUBLE);
(It is not clear whether this has any effect on the operation of the GNU maths library, but we have no evidence of it causing trouble.)
Some targets (such as the Alpha) may need special options for full IEEE conformance. See section `Hardware Models and Configurations' in Using and Porting GNU CC.
Code containing inconsistent calling sequences in the same file is
normally rejected--see section GLOBALS
.
(Use, say, ftnchek
to ensure
consistency across source files.
See section Generating Skeletons and Prototypes with f2c
.)
Mysterious errors, which may appear to be code generation problems, can
appear specifically on the x86 architecture with some such
inconsistencies. On x86 hardware, floating-point return values of
functions are placed on the floating-point unit's register stack, not
the normal stack. Thus calling a REAL
or DOUBLE PRECISION
FUNCTION
as some other sort of procedure, or vice versa,
scrambles the floating-point stack. This may break unrelated code
executed later. Similarly if, say, external C routines are written
incorrectly.
These options should be used only as a quick-and-dirty way to determine how well your program will run under different compilation models without having to change the source. Some are more problematic than others, depending on how portable and maintainable you want the program to be (and, of course, whether you are allowed to change it at all is crucial).
You should not continue to use these command-line options to compile a given program, but rather should make changes to the source code:
-finit-local-zero
DATA
, so that
`-finit-local-zero' is not needed.
Consider using `-Wuninitialized' (which requires `-O') to
find likely candidates, but
do not specify `-finit-local-zero' or `-fno-automatic',
or this technique won't work.
-fno-automatic
SAVE
statements.)
Many other compilers do this automatically, which means lots of
Fortran code developed with those compilers depends on it.
The effect of this is that all non-automatic variables and arrays
are made static, that is, not placed on the stack or in heap storage.
This might cause a buggy program to appear to work better.
If so, rather than relying on this command-line option (and hoping all
compilers provide the equivalent one), add SAVE
statements to some or all program unit sources, as appropriate.
Consider using `-Wuninitialized' (which requires `-O')
to find likely candidates, but
do not specify `-finit-local-zero' or `-fno-automatic',
or this technique won't work.
The default is `-fautomatic', which tells g77
to try
and put variables and arrays on the stack (or in fast registers)
where possible and reasonable.
This tends to make programs faster.
Note: Automatic variables and arrays are not affected
by this option.
These are variables and arrays that are necessarily automatic,
either due to explicit statements, or due to the way they are
declared.
Examples include local variables and arrays not given the
SAVE
attribute in procedures declared RECURSIVE
,
and local arrays declared with non-constant bounds (automatic
arrays).
Currently, g77
supports only automatic arrays, not
RECURSIVE
procedures or other means of explicitly
specifying that variables or arrays are automatic.
-fgroup-intrinsics-hide
EXTERNAL
for any external procedure
that might be the name of an intrinsic.
It is easy to find these using `-fgroup-intrinsics-disable'.
Aside from the usual gcc
options, such as `-O',
`-ffast-math', and so on, consider trying some of the
following approaches to speed up your program (once you get
it working).
On some systems, such as those with Pentium Pro CPUs, programs
that make heavy use of REAL(KIND=2)
(DOUBLE PRECISION
)
might run much slower
than possible due to the compiler not aligning these 64-bit
values to 64-bit boundaries in memory.
(The effect also is present, though
to a lesser extent, on the 586 (Pentium) architecture.)
The Intel x86 architecture generally ensures that these programs will work on all its implementations, but particular implementations (such as Pentium Pro) perform better with more strict alignment. (Such behavior isn't unique to the Intel x86 architecture.) Other architectures might demand 64-bit alignment of 64-bit data.
There are a variety of approaches to use to address this problem:
COMMON
and EQUIVALENCE
areas such
that the variables and arrays with the widest alignment
guidelines come first.
For example, on most systems, this would mean placing
COMPLEX(KIND=2)
, REAL(KIND=2)
, and
INTEGER(KIND=2)
entities first, followed by REAL(KIND=1)
,
INTEGER(KIND=1)
, and LOGICAL(KIND=1)
entities, then
INTEGER(KIND=6)
entities, and finally CHARACTER
and INTEGER(KIND=3)
entities.
The reason to use such placement is it makes it more likely
that your data will be aligned properly, without requiring
you to do detailed analysis of each aggregate (COMMON
and EQUIVALENCE
) area.
Specifically, on systems where the above guidelines are
appropriate, placing CHARACTER
entities before
REAL(KIND=2)
entities can work just as well,
but only if the number of bytes occupied by the CHARACTER
entities is divisible by the recommended alignment for
REAL(KIND=2)
.
By ordering the placement of entities in aggregate
areas according to the simple guidelines above, you
avoid having to carefully count the number of bytes
occupied by each entity to determine whether the
actual alignment of each subsequent entity meets the
alignment guidelines for the type of that entity.
If you don't ensure correct alignment of COMMON
elements, the
compiler may be forced by some systems to violate the Fortran semantics by
adding padding to get DOUBLE PRECISION
data properly aligned.
If the unfortunate practice is employed of overlaying different types of
data in the COMMON
block, the different variants
of this block may become misaligned with respect to each other.
Even if your platform doesn't require strict alignment,
COMMON
should be laid out as above for portability.
(Unfortunately the FORTRAN 77 standard didn't anticipate this
possible requirement, which is compiler-independent on a given platform.)
gcc
configuration subsystem).
The warning about this in the gcc
manual isn't
generally relevant to Fortran,
but using it will force COMMON
to be padded if necessary to align
DOUBLE PRECISION
data.
When DOUBLE PRECISION
data is forcibly aligned
in COMMON
by g77
due to specifying `-malign-double',
g77
issues a warning about the need to
insert padding.
In this case, each and every program unit that uses
the same COMMON
area
must specify the same layout of variables and their types
for that area
and be compiled with `-malign-double' as well.
g77
will issue warnings in each case,
but as long as every program unit using that area
is compiled with the same warnings,
the resulting object files should work when linked together
unless the program makes additional assumptions about
COMMON
area layouts that are outside the scope
of the FORTRAN 77 standard,
or uses EQUIVALENCE
or different layouts
in ways that assume no padding is ever inserted by the compiler.
main()
.
The recent one from GNU (glibc2
) will do this on x86 systems,
but we don't know of any other x86 setups where it will be right.
Read your system's documentation to determine if
it is appropriate to upgrade to a more recent version
to obtain the optimal alignment.
Progress is being made on making this work
"out of the box" on future versions of g77
,
gcc
, and some of the relevant operating systems
(such as GNU/Linux).
A package that tests the degree to which a Fortran compiler
(such as g77
)
aligns 64-bit floating-point variables and arrays
is available at ftp://alpha.gnu.org/gnu/g77/align/.
If you're using `-fno-automatic' already, you probably should change your code to allow compilation with `-fautomatic' (the default), to allow the program to run faster.
Similarly, you should be able to use `-fno-init-local-zero' (the default) instead of `-finit-local-zero'. This is because it is rare that every variable affected by these options in a given program actually needs to be so affected.
For example, `-fno-automatic', which effectively SAVE
s
every local non-automatic variable and array, affects even things like
DO
iteration
variables, which rarely need to be SAVE
d, and this often reduces
run-time performances.
Similarly, `-fno-init-local-zero' forces such
variables to be initialized to zero--when SAVE
d (such as when
`-fno-automatic'), this by itself generally affects only
startup time for a program, but when not SAVE
d,
it can slow down the procedure every time it is called.
See section Overly Convenient Command-line Options, for information on the `-fno-automatic' and `-finit-local-zero' options and how to convert their use into selective changes in your own code.
If you aren't linking with any code compiled using
f2c
, try using the `-fno-f2c' option when
compiling all the code in your program.
(Note that libf2c
is not an example of code
that is compiled using f2c
---it is compiled by a C
compiler, typically gcc
.)
Using an appropriate `-m' option to generate specific code for your CPU may be worthwhile, though it may mean the executable won't run on other versions of the CPU that don't support the same instruction set. See section `Hardware Models and Configurations' in Using and Porting GNU CC. For instance on an x86 system the compiler might have been built--as shown by `g77 -v'---for the target `i386-pc-linux-gnu', i.e. an `i386' CPU. In that case to generate code best optimized for a Pentium you could use the option `-march=pentium'.
For recent CPUs that don't have explicit support in the released version
of gcc
, it might still be possible to get improvements
with certain `-m' options.
`-fomit-frame-pointer' can help performance on x86 systems and others. It will, however, inhibit debugging on the systems on which it is not turned on anyway by `-O'.
Go to the first, previous, next, last section, table of contents.


When you work with us you are part of a team of committed collaborators. All aspects of our software development process are integrated,interactive and agile.
Our approach unifies design, development and product management to create exceptional products.
We start each project by understanding your business goals,the user's needs and the product requirements.
Then we help translate them into effective elegant solutions.
Before we sign a contract or even write a line of code our team will spend the necessary time needed to understand your product vision.
The outcome of this scoping session is a proposals or high-levle statement of work.
Based on your requirements, we can provide a complete offering or just the pieces you need.
Our design practice offers a full range of services including brand strategy, interaction and visual design and user experience testing.
Throughout your project, our designers create and implement visual design and workflows, solicit user feedback and work with you to make sure what gets built is what is needed.
All engineers are fluent in the latest enterprise, mobile and web development technologies.
They collaborate with your team to write, and improve code on a daily basis, using proven practices such as test-driven development and pair programming.
Planning and development is iterative. Because we are constantly coding and testing, the products we build are always ready to go live.
This iterative process allows for changes as business requirements evolve.


Yocto/Bvh
Ray-intersection and closet-point routines supporting points, lines, triangles and tetrahedra accelerated by a two-level bounding volume hierarchy (BVH). Tetrahedra support is still a work in progress.
The scene model is comprised of a set of shapes, each with its own BVH. Shapes are collections of points, lines, triangles or tetrahedras. each shape may contain only one element type. Shapes are organized into a scene by creating shape instances, each of which with its own transform. For now, we only support rigid transform (translation and rotation). But eventually we might be able to support generic transforms. Shape data is shared with application and not copied to save memory. Instance data is instead kept internally to allow for more flexibility.
The library supports two main queries. Ray-scene intersection for raytracing and point-scene overlap test for collision detection. Also for collision detection we support shape bounds overlap for broad-phase collisions. Queries and BVH build can be performed over the whole single or single shapes.
This library depends in yocto_math.h
Usage
- create a scene with
make_scene()
- for each shape, add shape data and transforms with
add_point_shape()
,add_line_shape()
,add_triangle_shape()
andadd_tetra_shape()
; to modify the frame callset_shape_frame()
- add shape instances with
add_instance()
- build the bvh with
build_scene_bvh()
- perform ray-interseciton tests with
intersect_ray()
- use early_exit=false if you want to know the closest hit point
- use early_exit=false if you only need to know whether there is a hit
- for points and lines, a radius is required
- for triangle and tetrahedra, the radius is ignored
- perform point overlap tests with
overlap_point()
to if a point overlaps with an element within a maximum distance- use early_exit as above
- for all primitives, a radius is used if defined, but should be very small compared to the size of the primitive since the radius overlap is approximate
- perform shape overlap queries with
overlap_shape_bounds()
- use
refit_bvh()
to recompute the bvh bounds if transforms or vertices are (you should rebuild the bvh for large changes); update the instances' transforms withset_instance_frame()
or `set_instance_transform(); shapes use shared memory, so no explicit update is necessary
History
- v 0.19: switch to matrices for transforms
- v 0.18: faster internal intersection
- v 0.17: removal of SAH build option (better use embree instead)
- v 0.16: use yocto_math in the interface and remove inline compilation
- v 0.15: move to add api
- v 0.14: added instances
- v 0.13: switch to .h/.cpp pair
- v 0.12: doxygen comments
- v 0.11: opaque API (allows for changing internals without altering API)
- v 0.10: internally use pointers for performance transparency
- v 0.9: [API change] use rigid frames rather than linear transforms
- v 0.8: [API change] added support for tetrahdedra and explicit shape ids
- v 0.7: [major API change] move to modern C++ interface
- v 0.6: internal refactoring
- v 0.5: removal of C interface
- v 0.4: use of STL containers
- v 0.3: cleaner interface based on opaque scene
- v 0.2: better internal intersections and cleaner bvh stats
- v 0.1: C++ implementation
- v 0.0: initial release in C99
Acknowledgements
This library includes code from "Real-Time Collision Detection" by Christer Ericson and from the Journal of Graphics Techniques.
Namespace ybvh
Accellerated ray-intersection and closet-point queries.
Struct scene
struct scene;
Opaque BVH scene.
Function make_scene()
scene* make_scene();
Init scene.
Function free_scene()
void free_scene(scene*& scn);
Free scene.
- Parameters:
- scn: scene to free
Function add_point_shape()
int add_point_shape(scene* scn, int npoints, const int* point, int nverts,
const ym::vec3f* pos, const float* radius);
Add shape
- Parameters:
- scn: scene
- npoints/point: point indices
- nverts: number of vertices
- pos/radius: vertex position and radius
- Returns:
- shape id
Function add_line_shape()
int add_line_shape(scene* scn, int nlines, const ym::vec2i* lines, int nverts,
const ym::vec3f* pos, const float* radius);
Add shape.
- Parameters:
- scn: scene
- nlines/line: line indices
- nverts: number of vertices
- pos/radius: vertex position and radius
- Returns:
- shape id
Function add_triangle_shape()
int add_triangle_shape(scene* scn, int ntriangles, const ym::vec3i* triangles,
int nverts, const ym::vec3f* pos, const float* radius);
Add shape
- Parameters:
- scn: scene
- ntriange/triangles: triangle indices
- nverts: number of vertices
- pos/radius: vertex position and radius
- Returns:
- shape id
Function add_tetra_shape()
int add_tetra_shape(scene* scn, int ntetra, const ym::vec4i* tetra, int nverts,
const ym::vec3f* pos, const float* radius);
Add shape
- Parameters:
- scn: scene
- npoints/point: point indices
- ntetra/tetra: tetrahedra indices
- nverts: number of vertices
- pos/radius: vertex position and radius
- Returns:
- shape id
Function add_point_shape()
int add_point_shape(
scene* scn, int nverts, const ym::vec3f* pos, const float* radius);
Add shape
- Parameters:
- scn: scene
- nverts: number of vertices
- pos/radius: vertex position and radius
- Returns:
- shape id
Function add_instance()
int add_instance(scene* scn, const ym::mat4f& xform,
const ym::mat4f& xform_inverse, int sid);
Add an instance.
- Parameters:
- scn: scene
- xform: instance transform
- xform_inverse: instance inverse transform
- sid: shape id
- Returns:
- instance id
Function add_instance()
inline int add_instance(scene* scn, const ym::frame3f& frame, int sid);
Add an instance.
- Parameters:
- scn: scene
- frame: instance transform
- sid: shape id
- Returns:
- instance id
Function set_instance_transform()
void set_instance_transform(scene* scn, int iid, const ym::mat4f& xform,
const ym::mat4f& xform_inverse);
Set an instance transform.
- Parameters:
- scn: scene
- iid: instance id
- xform: shape transform
- xform_inverse: inverse of shape transform
Function set_instance_frame()
inline void set_instance_frame(scene* scn, int iid, const ym::frame3f& frame);
Set an instance frame.
- Parameters:
- scn: scene
- iid: instance id
- frame: shape transform
Function set_instance_transform()
inline void set_instance_transform(
scene* scn, int iid, const ym::frame3f& frame);
Set an instance frame.
- Parameters:
- scn: scene
- iid: instance id
- frame: shape transform
Function build_scene_bvh()
void build_scene_bvh(scene* scn, bool equalsize = true, bool do_shapes = true);
Builds a scene BVH.
- Parameters:
- scn: object to build the bvh for
- equalsize: space-splitting tree (otherwise balanced tree)
- do_shapes: build shapes
Function build_shape_bvh()
void build_shape_bvh(scene* scn, int sid, bool equalsize = true);
Builds a shape BVH.
- Parameters:
- scn: object to build the bvh for
- sid: required shape
- equalsize: space-splitting tree (otherwise balanced tree)
Function refit_scene_bvh()
void refit_scene_bvh(scene* scn, bool do_shapes = false);
Refit the bounds of each shape for moving objects. Use this only to avoid a rebuild, but note that queries are likely slow if objects move a lot. Before calling refit, set the scene data.
- Parameters:
- scn: scene to refit
- do_instances: refit instances
- do_shapes: refit shapes
Function refit_shape_bvh()
void refit_shape_bvh(scene* scn, int sid);
Refit the bounds of each shape for moving objects. Use this only to avoid a rebuild, but note that queries are likely slow if objects move a lot. Before calling refit, set the scene data.
- Parameters:
- scn: scene to refit
- sid: shape id
Struct intersection_point
struct intersection_point {
float dist = 0;
int iid = -1;
int sid = -1;
int eid = -1;
ym::vec4f euv = {0, 0, 0, 0};
operator bool() const;
}
BVH intersection.
- Members:
- dist: distance
- iid: instance index
- sid: shape index
- eid: element index
- euv: element baricentric coordinates
- operator bool(): Check whether it was a hit.
Function intersect_scene()
intersection_point intersect_scene(
const scene* scn, const ym::ray3f& ray, bool early_exit);
Intersect the scene with a ray. Find any interstion if early_exit, otherwise find first intersection.
- Parameters:
- scn: scene to intersect
- ray: ray
- early_exit: whether to stop at the first found hit
- Returns:
- intersection point
Function intersect_shape()
intersection_point intersect_shape(
const scene* scn, int sid, const ym::ray3f& ray, bool early_exit);
Intersect the scene with a ray. Find any interstion if early_exit, otherwise find first intersection.
- Parameters:
- scn: scene to intersect
- sid: shape id
- ray: ray
- early_exit: whether to stop at the first found hit
- Returns:
- intersection point
Function intersect_instance()
intersection_point intersect_instance(
const scene* scn, int iid, const ym::ray3f& ray, bool early_exit);
Intersect the scene with a ray. Find any interstion if early_exit, otherwise find first intersection.
- Parameters:
- scn: scene to intersect
- sid: shape id
- ray: ray
- early_exit: whether to stop at the first found hit
- Returns:
- intersection point
Function overlap_instance_bounds()
void overlap_instance_bounds(const scene* scn1, const scene* scn2,
bool exclude_duplicates, bool exclude_self,
std::vector<ym::vec2i>* overlaps);
Returns a list of instance pairs that can possibly overlap by checking only they axis aligned bouds. This is only a conservative check useful for collision detection.
- Parameters:
- scn1, scn2: scenes to overlap
- skip_self: exlude self intersections
- skip_duplicates: exlude intersections (i1,i2) if (i2,i1) is already present
- Out Parameters:
- overlaps: vectors of shape overlaps
Function overlap_scene()
intersection_point overlap_scene(
const scene* scn, const ym::vec3f& pt, float max_dist, bool early_exit);
Finds the closest element that overlaps a point within a given radius.
- Parameters:
- scene: scene to check
- pt: ray origin
- max_dist: max point distance
- early_exit: whether to stop at the first found hit
- Returns:
- overlap point
Function overlap_shape()
intersection_point overlap_shape(const scene* scn, int sid, const ym::vec3f& pt,
float max_dist, bool early_exit);
Finds the closest element that overlaps a point within a given radius.
- Parameters:
- scene: scene to check
- sid: shape id
- pt: ray origin
- max_dist: max point distance
- early_exit: whether to stop at the first found hit
- Returns:
- overlap point
Function overlap_instance()
intersection_point overlap_instance(const scene* scn, int iid,
const ym::vec3f& pt, float max_dist, bool early_exit);
Finds the closest element that overlaps a point within a given radius.
- Parameters:
- scene: scene to check
- iid: instance id
- pt: ray origin
- max_dist: max point distance
- early_exit: whether to stop at the first found hit
- Returns:
- overlap point
Function compute_bvh_stats()
void compute_bvh_stats(const scene* scn, bool include_shapes, int& nprims,
int& ninternals, int& nleaves, int& min_depth, int& max_depth,
int req_shape = -1);
Compute BVH stats.


Kim Kardashian West and Sharon from 'Kath and Kim' are an extremely unlikely pairing in Uber Eats' new Australian ad
by Sharon Masige- Food delivery service Uber Eats has launched a new ad campaign featuring Kim Kardashian West and “Kath and Kim” character Sharon Strzelecki.
- The duo are part of Uber Eat’s ‘Tonight I’ll be Eating’ campaign with Strzelecki giving Kardashian West advice on how to pronounce Australian phrases like ‘noice’.
- The ad has lit up the Twitterverse, with many Aussies praising it and one user even claiming it was the ad they didn’t know they needed.
Noice.
Global businesswoman Kim Kardashian West has teamed up with beloved Aussie character Sharon Strzelecki for a new Uber Eats ad.
Strzelecki, who is played by comedian Magda Szubanski, graced our screens as a netball fanatic on the TV series “Kath and Kim” but this time she’s hanging out with a different “Kim”.
As part of the latest rendition of Uber Eats’ “Tonight I’ll be Eating” ad campaign, Strzelecki says she’ll be eating pesto gnocchi and garlic bread to keep her “carbed up” while Kardashian West orders an Aussie favourite – a chicken schnitty with chips and chicken salt.
Kardashian West even dons her own version of a netball uniform, with her initials KKW emblazoned on the front.
While waiting for their orders, Strzelecki also teaches Kardashian West how to pronounce ‘noice’.
With a slew of beauty products to her name and more than 150 million followers on Instagram, Uber said Kardashian West’s “cultural appeal is undeniable”.
“She’s a once in a generation influencer, while Sharon is the perfect Australian voice and comedic foil to the glamorous Californian,” Uber said in a statement.
Previous campaign ads featured other Australian and global celebrities including Rebel Wilson, Ruby Rose, Naomi Watts and Rafael Nadal.
Uber called “Sharon and Kim” it’s “most audacious, quirky and unexpected pairing yet.”
“With creative pairings like Sharon and Kim, small businesses are able to unlock the star power of international and homegrown talent to promote their restaurants,” Uber said.
The ad was by and large very well received on social media:
Some were happy with how far Kardashian West went to mimic Sharon’s outfit:
While this Twitter user said it was something they didn’t think they needed:


Grid
List
Info
Black Line Yellow Box
Desk Flowers
Fence Sign Reach
Green Grass Line
Fill Outline
Bollard Bag Black Grey
Three Shutters
Green Bag White Wall
Temporary Barrier Bin


SwiftKey Keyboard for iOS updated with voice typing support
by PradeepSwiftKey Keyboard app for iOS just got updated in App Store. This version 2.7.0 update comes with two new improvements. First, SwiftKey now supports voice typing. Yes, when you prefer to speak instead of type, you can use this new voice typing feature in SwiftKey. This feature works only for English language users for now. If you have English as your language, after installing this update, you can just tap the new microphone icon to begin the voice typing experience. In order to enter punctuations explicitly, try saying “new line.” This new update also adds “trending” GIFs section in the GIF panel.
SwiftKey app features:
Intelligent Keyboard:
- SwiftKey learns from you, including your word choice, emoji usage and more
- Swipe typing or tap-to-type, whichever you prefer
- Toolbar: the expandable menu filled with quick shortcuts
GIF and Emoji Keyboard:
- Express yourself with GIFs and emoji
- Send pictures as a sticker to your friends and family
- Find the emoji you like to use from our smiley library
Customize Your Keyboard:
- Customize your keyboard size and layout
- Dozens of colorful themes
- Make your own theme with your photo sticker as the background
Multilingual Messenger:
- Enable up to two languages at once
- SwiftKey supports over 150 languages
Download the update here from Apple App Store.


Beliver
Demons
Morning Glory
Old Town Road
Bulleya
Wake Me Up
Wake me up when September Ends
Buolevard of broken Dreams
Welcome to The Hotel California
Vande Matram
Jai Ho
More Coming Soon


Pat’s Salmon Cookies Sales
Home
Sales
Add New Location
Location Name
Min / Cust
Max / Cust
Avg Cookie / Sale
Submit


£85million star follows Manchester United on Twitter in HUGE transfer hint
by Mark BrusErling Haaland has been spotted dropping a potential transfer hint by following Manchester United on Twitter.
The Norwegian wonderkid is enjoying a superb season with a prolific run of form and some eye-catching displays in the Champions League.
MORE: Man United changing stance on Paul Pogba transfer as he picks preference between Real Madrid & Juventus
This has led to rumours of interest from United in a potential £85million deal, and he’s now fuelled that speculation in a big way.
See below as Haaland has just started following Man Utd on Twitter…
The 19-year-old striker also follows MUFC forward Marcus Rashford, so it may be that he’s trying to get the attention of key figures at Old Trafford.
It’s worth noting that Haaland has also been linked with the likes of Liverpool and Real Madrid, but it seems he’s hinting at a preference for a move to Manchester.
If the Red Devils could get this signing done this January, Haaland could be a superb long-term purchase as he shows signs of becoming one of the best strikers in the world.


Japan scraps cherry blossom party amid Abe cronyism criticism
TOKYO: The Japanese government said on Wednesday (Nov 13) it would scrap next year's annual cherry blossom party after Prime Minister Shinzo Abe came under fire amid claims he invited too many of his own supporters.
The publicly funded event has taken place in a Tokyo park since 1952 to honour people for their achievements, with the great and the good of Japanese political life mingling under the world-famous cherry blossom trees.
But opposition politicians have taken aim at Abe, claiming he brought along 850 supporters from his local constituency for the festival reportedly costing around ¥55 million (US$504,000) from the public purse.
In a surprise announcement, Chief Cabinet Secretary Yoshihide Suga told reporters that the government had "listened to various opinions" and as a result decided to shelve next year's party.
Suga also pledged the government would "clarify the criteria for inviting guests and make the invitation process transparent."
The number of guests invited to the event is steadily increasing and so is the budget.
Local news agency Kyodo News said about 18,000 people took part this year - up from between 7,000 and 10,000 from before Abe came to power in 2012.
The ¥55 million spent last year is also nearly double the budget from 2014, Kyodo added.
Japan's cherry blossom ("sakura") season is eagerly anticipated by locals and visitors alike.
The season is traditionally celebrated with "hanami", or viewing parties, in cherry blossom hotspots, with picnics organised beneath the trees.
In general, blooms begin as early as March in the southern island of Kyushu and appear as late as May in northernmost Hokkaido.


The evolution of a cell’s state is function of the states of the neighborhood’s cells. The geometry and the number of cells that are part of the neighborhood depends on the tessellation type, but it has to have three fundamental properties:
Locality. It should involve only a ’limited’ number of cells.
Invariance. It should not be changed during the evolution.
Homogeneity. It has to be the same for each cell of the automaton.
Typically neighborhood “surrounds” the central cell. For 1-D cellular automata its borders are identified with a number \(r \) called radius [@wolfram1983]. A \(r=2\) identify \(n=2r+1\) cells in a 1D lattice: the central cell plus the right and left cells. Typical 2D cellular space neighborhood are the those of Moore and von Neumann neighborhood. The number of cells in the Moore neighborhood of range r is the odd squares \((2r+1)^2,\) the first few of which are 1, 9, 25, 49, 81, and so on as r is increased. Von Neumann’s one consist of the central cell plus the cell at north, south, east, and west of the central cell itself. Moore’s ( \(r=1\)) one add the farther cells at north-east, south-east, south-west and north-west (see figure [mooreNeigh]).


Hacktoberfest Issue Finder
Filter by language
{{this.selectedLanguage}}
{{ isFetching ? `Loading...` : `View more` }}


If you are getting married you will love www.eWedding.com. You can create a fully-featured wedding website. You can post dates, directions, RSVP, registries and more. You can also upload unlimited photos and make changes around the clock. Even change the theme of your website as often as you like. Create the most memorable, most beautiful website on eWedding.com in less than five minutes. You can create free website or a paid one which will have more features. Check it out online and choose a website according to your budget. Use our discount coupons to save money. Make your special day, memorable and share it online with your friends and family on eWedding.com.
If you are about to marry, check out eWedding.com. You can do RSVP management. You can also upload videos, share your proposal video with your family and loved ones online. You can also put out fun quizzes and polls for your guests. Find out how much or how little your guests know you etc. There are lots that you can do to make your wedding website memorable. Save your special memories online on eWedding.com.
Check out eWedding.com for free and paid packages. You can get from free to platinum packages. Choose the one that suits you the best. They are affordable and very user friendly. You can get unlimited support, unlimited updates and password protection. Make your wedding fun, memorable and extra special. Make a fun website and share it with your friends and family.


Runtime: 21:32:55.468
...air break...
12:41 PM
Rumba Soyo
La Rumba Soyo
Released in 2014 by Cumbancha
Northwest Artist!
Postizo
Marc Ribot Y Los Cubanos Postizos
Released in 1998 by Atlantic
Northwest Artist!
In The Woods
Emma Jean
Released in 2014 by Truth & Soul
Northwest Artist!
...air break...
12:27 PM
...air break...
12:11 PM


The greenhouse effect refers to the way that certain gases, primarily water vapor, carbon dioxide, methane, and ozone, trap heat inside the Earth's atmosphere. These four gases are commonly called greenhouse gases.


WITNESS LIST Pensions & Investments Committee March 26, 2001-8:00A HB 1428 For: Schaefer, Herb (Self) Williams, Jim (Self) On: Froh, Joseph (Texas County & District Retirement System) Registering, but not testifying: For: Raab, Ted (Texas State Employees Union) HB 2031 For: Lathrop, Matthew (The American Legislative Exchange Council) On: Nail, William (ERS) Rusher, Steven (ERS) Registering, but not testifying: For: Allen, Anne (TIAA-CRFF) Myers, Theresa (Nationwide Retirement Solutions) Against: Anderson, Gary (Texas Public Employees Association) Homer, Andrew (Texas Public Employees Association) Raab, Ted (Texas State Employees Union) HB 2122 On: Sandefer, Morris (Fire Fighters Pension Commission) Registering, but not testifying: For: Campbell, Helen (State Firemens & Fire Marshalls' Association) HB 2447 For: Allen, Anne (TIAA-CREF) Myers, Theresa (Nationwide Retirement Solutions) Against: Lara, Rene (Texas Federation Of Teachers) Raab, Ted (Texas State Employees Union) Romo, Joel (Association Of Texas Professional Educators) On: Lehr, Mike (Texas Retired Teachers Association) Registering, but not testifying: Against: Homer, Andrew (Texas Public Employees Association) HB 3015 For: Allen, Danny (Self and Brobeck,Phleger & Harrison, LLP) Bright, Mike (The Arc of Texas) Conger, Tim (American Heart Association) Headrick, Kelly (American Cancer Society) Wetmore, Elaine (Austin Entrepreneurs Foundation) On: Crawford, Denise (State Securities Board) HB 3407 Registering, but not testifying: For: Fickel, Ann (Texas Classroom Teachers Association) Kelly, Jack (Texas State Teachers Association) Romo, Joel (Association Of Texas Professional Educators) HB 3471 For: Kester, David (Self and Harris County) Registering, but not testifying: For: Lee, Donald (Texas Conference Of Urban Counties) HB 3564 For: Peden, R. Scott (Life Partners Inc.) On: Crawford, Denise (State Securities Board)


Umemployment Rate
Block Groups 4 & 5
Census Track
Suffolk County
23.2%
21.7%
10.6%
Great Boston
Massachusetts
8.3%
8.9%


Preparation time
30 mins to 1 hour
Cooking time
over 2 hours
Serves
Serves 6-8
Raymond Blanc cleverly matches pork with intensely flavoured plums in this wonderfully rich and fruity dish.
To dry the plums, preheat the oven to 100C/200F/Gas ¼. Place the plum halves on a baking tray and place in the oven for two hours. This can be done two days in advance and the dried plums kept in a container in the fridge.
For the pork, preheat the oven to 220C/425F/Gas 7. Open up the pork loin and flatten in on the work surface, fat-side down. Season the plums with sea salt and freshly ground black pepper and place three-quarters of them along the middle of the pork loin. Roll the loin up and secure both ends lightly with skewers then tie the parcel with four turns of string and remove the skewers.
Chop the remaining plums and reserve for the sauce. Heat the rapeseed oil in a heavy-duty roasting pan set over a medium heat and colour the pork bones and trimmings for 7-10 minutes until lightly golden-brown then remove the pan from the heat.
Heat the vegetable oil in a large non-stick frying pan on a medium heat and crisp the skin of the pork loin for 7-8 minutes or until lightly golden all over, then remove the pan from the heat.
Put the bones in a roasting tin and sit the pork loin on top. Add the tomato, garlic and thyme and roast in the oven for 30 minutes. Add the water, and Madeira if using, to create the jus then turn down the oven to 180C/350F/Gas 4, cover the tin loosely with tin foil and cook for a further 35 minutes. Once cooked, add 100ml/3½fl oz of water to lengthen the jus if needed. Place the pork loin on a warmed plate and allow to rest for 30 minutes.
Tip the roasting tin slightly and spoon out half the fat. Strain the remaining jus through a fine sieve into a medium casserole, heat gently then add the reserved chopped plums, season to taste with sea salt and freshly ground black pepper and set aside in a warm place.
To serve, cut away the strings from the pork loin, carve into 8-10 slices and pour the juices released from the meat into the plum sauce. Arrange the pork on a warmed serving dish and pour over the sauce.


Unsurprisingly, a majority of people move to other Bay area counties, primarily those within a reasonable commute distance to San Francisco. The top 5 counties in CA are directly East and South of San Francisco, and on public transportation routes. Los Angeles county is a bit of a surprise, and housing and opportunities in Los Angeles could explain some of LA's popularity.
The main counties outside of California are: New York County (Manhattan), New York, King County, Washington, Multnomah County, Oregon, Kings County (Brooklyn) New YHork, and Cook County Illinois. The data analysis in social factors, housing and opportunities may explain some of the reasons for moving out of California.


In this experiment, we are interested in how people reason about people’s performance in classes. We will ask you to give us your opinion on some statements.
This experiment should take about 3 minutes to complete.
(Note: you won't be able to preview this HIT before accepting it.)
You must accept the HIT in order to continue.
By answering the following questions, you are participating in a study being performed by cognitive scientists in the Stanford Department of Psychology. If you have questions about this research, please contact Erin Bennett at<EMAIL_ADDRESS>or Noah Goodman at<EMAIL_ADDRESS>You must be at least 18 years old to participate. Your participation in this research is voluntary. You may decline to answer any or all of the following questions. You may decline further participation, at any time, without adverse consequences. Your anonymity is assured; the researchers who have requested your participation will not receive any personal information about you.
Thanks! Just a few more questions:
What do you think this experiment was about?
* Have you ever heard of "mindsets"?
* Please describe what a "fixed" mindset is:
* What is your gender?
We would be interested in any comments you have about this experiment. Please type them here:
Would you like to hear more about this study?
* indicates a required field
Please answer the required questions.
Imagine that you are taking a test in a math class.
|
very unlikely
very likely
|
|
Please make sure to adjust all the sliders before continuing (or tap the slider if you think it's already in the right position).
Please show how much you agree or disagree with each statement by adjusting the slider.
|
strongly disagree
strongly agree
|
|
Please make sure to adjust all the sliders before continuing (or tap the slider if you think it's already in the right position).


We are re-opening the church building for morning services in person from Sunday 13th September at 10.45am. Due to social distancing regulations, we are required to limit numbers attending. If you would like to pre-book a place to attend, please email<EMAIL_ADDRESS>by 5pm on the Friday before the service you are hoping to attend. All those attending must wear a face-covering, in line with government regulations, unless you have an exemption for health or age reasons.
For those unable to attend in person, we will be live-streaming the morning service via our YouTube channel
Evening services and other activities will continue to take place via Zoom. Contact the church on the above email address for more details.
If you are in need of any support, whether practically, emotionally, or spiritually, please don’t hesitate to be in touch.
David Puttick
Pastor
Mirfield Evangelical Church


Schematix is a tool for those who face the problem of Data Wrangling: the art, or science, or conforming your data to a desired format. Data analysis tools are extremely high in demand. However, one known issue with data analysis is an inconsistency in formatting between different data sources. Is my data compatible with the analysis tool I’m trying to use? This problem is only exacerbated when data is represented inconsistently between various mediums. Take for example a team of two, each trying to represent the same structured data. Let’s say that one person decided to create an Excel spreadsheet while the other wrote a Python script to populate a CSV file. What if they chose inconsistent names of attributes for enumerated types (i.e. “female” vs. “f” vs. “Female”)? What if one person decided to leave some cells blank, while the other didn’t? What if the person entering into Excel had typos that were corrupting various aggregation results? Suddenly, the team’s simple task of trying to merge and aggregate their data with some analysis tool becomes much more complicated.


OriginBasedAlgoEQII Class Reference
This class implements equilibration II strategy for origin-based algorithms. More...
#include <OriginBasedAlgoEQII.h>
Inheritance diagram for OriginBasedAlgoEQII:
Collaboration diagram for OriginBasedAlgoEQII:
Public Member Functions | |
| OriginBasedAlgoEQII (OriginSet *originSet, StarNetwork *net, AddHook *component, ConvMeasure *conv, FPType timeLimit, int maxNbIter) | |
| Public Member Functions inherited from OriginBasedAlgo | |
| OriginBasedAlgo (OriginSet *originSet, StarNetwork *net, AddHook *component, ConvMeasure *conv, FPType timeLimit) | |
| Public Member Functions inherited from EqAlgo | |
| virtual FPType | getTotalConvTime () |
| virtual FPType | getTotalPureIterTime () |
| virtual FPType | getInitialisationTime () |
| int | execute () |
Private Member Functions | |
| bool | mainLoop (OriginBush *bush) |
Private Attributes | |
| const int | maxNbIter_ |
Additional Inherited Members | |
| Protected Member Functions inherited from OriginBasedAlgo | |
| virtual void | doSmthAfterOrigins () |
| Protected Member Functions inherited from EqAlgo | |
| EqAlgo (AddHook *component, StarNetwork *net, FPType timeLimit, ConvMeasure *conv) | |
| virtual bool | isConverged () |
| Protected Attributes inherited from EqAlgo | |
| ConvMeasure * | conv_ |
| StarNetwork * | net_ |
Detailed Description
This class implements equilibration II strategy for origin-based algorithms.
- Warning
- Equilibration II might not converge in case of high precision.
Constructor & Destructor Documentation
| OriginBasedAlgoEQII::OriginBasedAlgoEQII | ( | OriginSet * | originSet, |
| StarNetwork * | net, | ||
| AddHook * | component, | ||
| ConvMeasure * | conv, | ||
| FPType | timeLimit, | ||
| int | maxNbIter | ||
| ) |
- Parameters
-
maxNbIter maximum number of iteration in Equilibration II.
Member Function Documentation
|
privatevirtual |
Performs main operations made during one iteration for a given origin. It implements equilibration I. Equilibration II over-rides this method. For details see OriginBasedAlgoEQII.
- Returns
- true if current bush was equilibrated, false otherwise. The return value is needed only for equilibration II.
Reimplemented from OriginBasedAlgo.
The documentation for this class was generated from the following files:
- OriginBasedAlgoEQII.h
- OriginBasedAlgoEQII.cpp


Detailed Description
Master mode TWI driver for the AT90USB1287, AT90USB1286, AT90USB647, AT90USB646, ATMEGA16U4 and ATMEGA32U4 AVRs.
- Note:
- This file should not be included directly. It is automatically included as needed by the TWI driver dispatch header located in LUFA/Drivers/Peripheral/TWI.h.
Function Documentation
| static void TWI_Init |
( |
void |
) |
[inline, static] |
Initialises the TWI hardware into master mode, ready for data transmission and reception. This must be before any other TWI operations.
| static bool TWI_ReceiveByte |
( |
uint8_t *const |
Byte, |
|
|
const bool |
LastByte |
|
) |
| [inline, static] |
Receives a byte from the currently addressed device on the TWI bus.
- Parameters:
-
| [in] | Byte | Location where the read byte is to be stored |
| [in] | LastByte | Indicates if the byte should be ACKed if false, NAKed if true |
- Returns:
- Boolean true if the byte reception successfully completed, false otherwise
| static bool TWI_SendByte |
( |
const uint8_t |
Byte ) |
[inline, static] |
Sends a byte to the currently addressed device on the TWI bus.
- Parameters:
-
| [in] | Byte | Byte to send to the currently addressed device |
- Returns:
- Boolean true if the recipient ACKed the byte, false otherwise
| static void TWI_ShutDown |
( |
void |
) |
[inline, static] |
Turns off the TWI driver hardware. If this is called, any further TWI operations will require a call to TWI_Init() before the TWI can be used again.
| bool TWI_StartTransmission |
( |
const uint8_t |
SlaveAddress, |
|
|
const uint8_t |
TimeoutMS |
|
) |
| |
Begins a master mode TWI bus communication with the given slave device address.
- Parameters:
-
| [in] | SlaveAddress | Address of the slave TWI device to communicate with |
| [in] | TimeoutMS | Timeout period within which the slave must respond, in milliseconds |
- Returns:
- Boolean true if the device is ready for data, false otherwise
| static void TWI_StopTransmission |
( |
void |
) |
[inline, static] |
Sends a TWI STOP onto the TWI bus, terminating communication with the currently addressed device.


Aside from the built-in schemes, such as http
and
qrc
, Qt WebEngine may be extended with custom
schemes by creating custom scheme handlers.
This is a simple HTML page loaded from a custom scheme and
displayed by a QWebEngineView
. Even the Quit button
below is a standard HTML <button>
element.
Read the documentation to find out
-
How to create a custom scheme handler which serves HTML and handles HTML form submissions.
-
How to prevent ordinary web content from accessing the custom scheme.
-
How to prevent any other scheme from submitting HTML form data.


Please fill in this form to create a new order.
Info about order:
Info about shipment address:
Info about customer:
Please fill in this form to create a new product.
Info about product:
Edit


Search continues for 12-year-old girl who vanished 5 days ago in Osaka
OSAKA — Police in Osaka said Friday they have not been able to find any clues as to the whereabouts of a 12-year-old girl who vanished after leaving her home on the morning of Nov 17.
Iroha Akasaka, a sixth-grade student who lives in Osaka’s Sumiyoshi Ward, left home after eating breakfast at around 7 a.m. last Sunday and has not been seen or heard from since, Fuji TV reported. She had a smartphone with her but it has apparently been turned off.
Iroha is 150 centimeters tall with a slender build, short black hair.
Police said they have received about 40 tips regarding possible sightings of Iroha, but none of the information has led to any promising leads. On Thursday, more than 60 people searched around her neighborhood.
Police have asked anyone who may have seen Iroha since Sunday to call them at 06-6675-1234.
© Japan Today


Compiler Services: Processing untyped syntax tree
This tutorial demonstrates how to get the untyped abstract syntax tree (AST) for F# code and how to walk over the tree. This can be used for creating tools such as code formatter, basic refactoring or code navigation tools. The untyped syntax tree contains information about the code structure, but does not contain types and there are some ambiguities that are resolved only later by the type checker. You can also combine the untyped AST information with the API available from editor services.
NOTE: The FSharp.Compiler.Service API is subject to change when later versions of the nuget package are published
Getting the untyped AST
To access the untyped AST, you need to create an instance of FSharpChecker
.
This type represents a context for type checking and parsing and corresponds either
to a stand-alone F# script file (e.g. opened in Visual Studio) or to a loaded project
file with multiple files. Once you have an instance of FSharpChecker
, you can
use it to perform "untyped parse" which is the first step of type-checking. The
second phase is "typed parse" and is used by editor services.
To use the interactive checker, reference FSharp.Compiler.Service.dll
and open the
SourceCodeServices
namespace:
1: 2: 3: |
|
Performing untyped parse
The untyped parse operation is very fast (compared to type checking, which can
take notable amount of time) and so we can perform it synchronously. First, we
need to create FSharpChecker
- the constructor takes an argument that
can be used to notify the checker about file changes (which we ignore).
1: 2: |
|
To get the AST, we define a function that takes file name and the source code
(the file is only used for location information and does not have to exist).
We first need to get "interactive checker options" which represents the context.
For simple tasks, you can use GetProjectOptionsFromScriptRoot
which infers
the context for a script file. Then we use the ParseFile
method and
return the ParseTree
property:
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: |
|
Walking over the AST
The abstract syntax tree is defined as a number of discriminated unions that represent
different syntactical elements (such as expressions, patterns, declarations etc.). The best
way to understand the AST is to look at the definitions in ast.fs
in the source
code.
The relevant parts are in the following namespace:
1:
|
|
When processing the AST, you will typically write a number of mutually recursive functions that pattern match on the different syntactical elements. There is a number of elements that need to be supported - the top-level element is module or namespace declaration, containing declarations inside a module (let bindings, types etc.). A let declaration inside a module then contains expression, which can contain patterns.
Walking over patterns and expressions
We start by looking at functions that walk over expressions and patterns - as we walk,
we print information about the visited elements. For patterns, the input is of type
SynPat
and has a number of cases including Wild
(for _
pattern), Named
(for
<pat> as name
) and LongIdent
(for a Foo.Bar
name). Note that the parsed pattern
is occasionally more complex than what is in the source code (in particular, Named
is
used more often):
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: |
|
The function is recursive (for nested patterns such as (foo, _) as bar
), but it does not
call any of the functions defined later (because patterns cannot contain other syntactical
elements).
The next function iterates over expressions - this is where most of the work would be and
there are around 20 cases to cover (type SynExpr.
and you'll get completion with other
options). In the following, we only show how to handle if .. then ..
and let .. = ...
:
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: |
|
The visitExpression
function will be called from a function that visits all top-level
declarations inside a module. In this tutorial, we ignore types and members, but that would
be another source of calls to visitExpression
.
Walking over declarations
As mentioned earlier, the AST of a file contains a number of module or namespace declarations
(top-level node) that contain declarations inside a module (let bindings or types) or inisde
a namespace (just types). The following functions walks over declarations - we ignore types,
nested modules and all other elements and look only at top-level let
bindings (values and
functions):
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: |
|
The visitDeclarations
function will be called from a function that walks over a
sequence of module or namespace declarations. This corresponds, for example, to a file
with multiple namespace Foo
declarations:
1: 2: 3: 4: 5: 6: 7: 8: 9: |
|
Now that we have functions that walk over the elements of the AST (starting from declaration, down to expressions and patterns), we can get AST of a sample input and run the above function.
Putting things together
As already discussed, the getUntypedTree
function uses FSharpChecker
to run the first
phase (parsing) on the AST and get back the tree. The function requires F# source code together
with location of the file. The location does not have to exist (it is used only for location
information) and it can be in both Unix and Windows formats:
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: |
|
When you run the code in F# interactive, you can enter tree;;
in the interactive console and
see pretty printed representation of the data structure - the tree contains a lot of information,
so this is not particularly readable, but it gives you good idea about how the tree looks.
The returned tree
value is again a discriminated union that can be two different cases - one case
is ParsedInput.SigFile
which represents F# signature file (*.fsi
) and the other one is
ParsedInput.ImplFile
representing regular source code (*.fsx
or *.fs
). The implementation
file contains a sequence of modules or namespaces that we can pass to the function implemented
in the previous step:
1: 2: 3: 4: 5: 6: 7: |
|
Summary
In this tutorial, we looked at basic of working with the untyped abstract syntax tree. This is a comprehensive topic, so it is not possible to explain everything in a single article. The Fantomas project is a good example of tool based on the untyped AST that can help you understand more. In practice, it is also useful to combine the information here with some information you can obtain from the editor services discussed in the next tutorial.


This tests XMLSerializer on different node types. If the test is successful, there should be five lines of output. The first line should be the child1 tag. The second should be the child2 tag. The third one should be a comment, the fourth one should be the complete document and the fifth one should be the complete document but serialized from a document fragment node.


ASOS accused of 'laughing at plus size bodies' with ballerina fat suit game
by Laura AbernethyASOS has removed a game where players are encouraged to play classic game charades in a blow-up Ballerina suit after a plus-size blogger accused them of ‘laughing at a body that looks like mine’.
Danielle Vanier posted pictures from the ASOS website on Twitter and people weren’t impressed with the product.
It features a blow-up suit, designed to make the player look larger while wearing a pink dress.
The £30 game is made by Typo but was also being sold on the ASOS website in the UK.
 Dance is for EVERYBODY!!’
Another user added: ‘No not ASOS as well. Why isn’t there one place we can go without feeling fear of being fat-shamed?’
‘You sell clothes to bodies that are parodied in this way and have no problem taking our money. Hang your head in shame,’ someone else said, referring to their extensive Curve range.
ASOS quickly replied to Danielle’s tweet and said that they had decided to withdraw the product from the site because of her concerns.
A spokesperson said: ‘Thank you for making us aware of this. It was never our intention to cause offence, we’ve decided to remove the product from our site.
‘As a responsible fashion retailer we’re aware of the importance of promoting positive body image, so we appreciate your feedback.’
Danielle told her followers that she had been contacted by the team and she was glad they had said they would remove this product.
She added: ‘ I feel like this is a really positive outcome and very happy for their prompt response.’
A spokesperson for ASOS told Metro.co.uk: ‘We’re sorry this item caused offence, it was not our intention and we have removed the product from site.’
The item was also for sale on the Typo website but is no longer available.
We contacted Typo for comment and will update this article when they respond.


The small town of Livingston sits at the mouth of the Rio Dulce in Honduras Bay. It has no road or rail connections to the hinterland, just boats and planes. The centre of the town is at the top of a steep hill.
It is not a port to be entered at night, as the lights are unreliable and fishermen often set their nets then, too.
There is a wide sand bar at the entrance to Rio Dulce; boats with a draft of over 5 ft (1.50 m) must enter at high tide and the maximum draft that can be carried through at high tide is 7.5 ft (2.20 m). Advice on the state of the tide may be obtained on Channel 68.
Cruisers also warn that the location of the outer marker buoy can not be trusted and it is recommended to request a local guide on first-time entering (contact Raul, approximate price $25). It is well worth the small fee as the cost for a tow if you get stuck is $250.
Last updated September 2012.
Clearance is straightforward here as officials are used to dealing with yachts.
Fly the Q flag and the officials will come out to the yacht in office hours (closed 1300-1500), for initial clearance and inspection. Customs will take the zarpe from the last port and ship's papers, Immigration take the passports. The captain must collect these later from the shore offices, with the necessary entry stamps as well as a new zarpe and cruising permit.
This can all be done in one day if arriving early enough, and some cruisers have reported it only taking 2 hours. Quetzales will be needed to pay various fees.
If you choose, there is a cruisers customs agent, "Raoul", half a block from the Municipal Dock. He has been recommended by many. His fee is approx. US$12 on top of what the authorities charge. It is quite possible that he will come out to the boat with the officials to offer his services.
Last updated September 2012.
The holding in the river is not good and, in addition, be aware of the significant amount of traffic on the water at night.
La Marina went out of business in 2008, however yachts can berth on the Municipal Dock at Livingston. The fee is 20 Q./day, or US$2.50.
Dinghies can be moored at the dock in front of the hotel "Big Mama" from which it is possible to walk into the town.
Last checked September 2012.


# Change Log
## 0.1.34
- Make SourceNode work with windows style (“rn”) newlines. Issue #103.
- Fix bug involving source contents and the SourceMapGenerator.prototype.applySourceMap. Issue #100.
## 0.1.33
- Fix some edge cases surrounding path joining and URL resolution.
- Add a third parameter for relative path to SourceMapGenerator.prototype.applySourceMap.
- Fix issues with mappings and EOLs.
## 0.1.32
- Fixed a bug where SourceMapConsumer couldn’t handle negative relative columns (issue 92).
- Fixed test runner to actually report number of failed tests as its process exit code.
- Fixed a typo when reporting bad mappings (issue 87).
## 0.1.31
- Delay parsing the mappings in SourceMapConsumer until queried for a source location.
- Support Sass source maps (which at the time of writing deviate from the spec in small ways) in SourceMapConsumer.
## 0.1.30
- Do not join source root with a source, when the source is a data URI.
- Extend the test runner to allow running single specific test files at a time.
- Performance improvements in SourceNode.prototype.walk and SourceMapConsumer.prototype.eachMapping.
- Source map browser builds will now work inside Workers.
- Better error messages when attempting to add an invalid mapping to a SourceMapGenerator.
## 0.1.29
- Allow duplicate entries in the names and sources arrays of source maps (usually from TypeScript) we are parsing. Fixes github issue 72.
## 0.1.28
- Skip duplicate mappings when creating source maps from SourceNode; github issue 75.
## 0.1.27
- Don’t throw an error when the file property is missing in SourceMapConsumer, we don’t use it anyway.
## 0.1.26
- Fix SourceNode.fromStringWithSourceMap for empty maps. Fixes github issue 70.
## 0.1.25
- Make compatible with browserify
## 0.1.24
- Fix issue with absolute paths and file:// URIs. See https://bugzilla.mozilla.org/show_bug.cgi?id=885597
## 0.1.23
- Fix issue with absolute paths and sourcesContent, github issue 64.
## 0.1.22
- Ignore duplicate mappings in SourceMapGenerator. Fixes github issue 21.
## 0.1.21
- Fixed handling of sources that start with a slash so that they are relative to the source root’s host.
## 0.1.20
- Fixed github issue #43: absolute URLs aren’t joined with the source root anymore.
## 0.1.19
- Using Travis CI to run tests.
## 0.1.18
- Fixed a bug in the handling of sourceRoot.
## 0.1.17
- Added SourceNode.fromStringWithSourceMap.
## 0.1.16
- Added missing documentation.
- Fixed the generating of empty mappings in SourceNode.
## 0.1.15
- Added SourceMapGenerator.applySourceMap.
## 0.1.14
- The sourceRoot is now handled consistently.
## 0.1.13
- Added SourceMapGenerator.fromSourceMap.
## 0.1.12
- SourceNode now generates empty mappings too.
## 0.1.11
- Added name support to SourceNode.
## 0.1.10
- Added sourcesContent support to the customer and generator.


Celebrated as the Granary of Kerala, Palakkad is a vast stretch of fertile plains interspersed with hills, rivers, mountain streams and forests. The gateway to Kerala from the north, a 40 kilometre break in the mountains known as the Palakkad Gap gives access to this land situated at the foot of the Western Ghats. The pass acts as a corridor between Kerala and the neighbouring Tamil Nadu and played a key role in the trade relations between the east and west coasts of peninsular India. Deriving its name from the Malayalam words Pala (Alsteriascholaris) and Kadu (forest), this place was once a stunning expanse of forest covered with the sweet-scented flowers of the Pala tree. A potpourri of Tamil and Kerala culture, some of the finest Carnatic musicians hail from this district which continues to be a principally agrarian society.
Blooming with in rare varieties of medicinal plants, orchids and fauna, the Parambikkulam Wildlife Sanctuary is hailed to be one of the best wildlife sanctuaries in South India.
The Silent Valley National Park, with its lush green forests and beautiful views of the rich flora, is a popular destination for nature and wildlife lovers in Kerala. With its long, detailed history and the unique status of a Rain Forest, this national park is truly a sight to visit. The well-planned Safari and the beautiful stop-overs around the park only make a trip to this part of Kerala more worthwhile.
The Palakkad Fort in Kerala is a beautiful historical monument that has gently integrated its high walls with its surrounding green gardens. One of the most well-preserved forts in the state of Kerala, the Palakkad fort was built in the 1766 AD by Hyder Ali and is now a protected monument under the Archaeological Survey of India. This picturesque fort is located in the heart of Palakkad town at the foothills of the Sahyadris range in a labyrinth of dense forests and crisscrossing cascading rivers. The mighty fort is spread over an area of 60,702 square meters and is immensely famous for its architecture, which displays the efficiency of the French craftsman. The magnificent fortress of Pallakad is an essential part of history, and its construction is majestic as well


ANY GIVEN SUNDAY ** (out of five stars) A review by Jamey Hughton
Starring-Al Pacino, Cameron Diaz, Jamie Foxx, Dennis Quaid, James Woods and LL Cool J Director-Oliver Stone Rated 14A
MOVIE VIEWS by Jamey Hughton http://Welcome.to/MovieViews
I can see a decent sports movie struggling to break free of Oliver Stone's `Any Given Sunday'. It's an entertaining movie that offers both insight and excitement into the rock-em, sock-em profession of pro football. Unfortunately, the director seems to have only one priority on his mind: sprucing up the film with an assortment of fancy camera maneuvers. In altering each frame with quick-flash photography and dizzying, in-your-face editing, Stone appears to have completely ignored the matter of plausible character development and football politics. We see glimpses of greatness, but `Any Given Sunday' has its agenda all tangled in technical gobbledy-gook. It grows tiresome and monotonous. Yes, Stone has pulled a Brian DePalma.
Matters of importance are pushed aside right from the get-go. Tony D'Amato (Al Pacino), coach of the struggling Miami Sharks, finds his team stuck in a losing rut. Aging Quarterback Cap Rooney (Dennis Quaid) appears to be losing his touch, and D'Amato can't seem to ignite any passion in his squad. When Cap is injured on the field, and after a patch of unlikely events occur, third-string QB Willie Beaman (Jamie Foxx) is brought into the game. Once in the huddle (and this becomes an in-game ritual), Beaman horks all over the field. Nerves, you see. Eventually though, the ancy youngster wins the game for his teammates, sparking his rise to fame in the football world - the endorsements, the music videos, etc. - and Stone straps us in for the jolting ride of behind-the-scenes stress and fury that the business is apparently like. And I believe it. There is some intriguing insight posed, but in the big scheme of things, Stone fumbles the ball.
The problem with the director's visual approach is this: he uses extravagant editing devices when a more conventional approach would have been appropriate. Football is an exciting game to watch, but Stone seems to think dizzying the audience with an assault on the senses will only add to the adrenaline rush. I guess he is mistaken. `Any Given Sunday' is a visual kaleidoscope that leaves the audience in a frustrated stupor more frequently than it excites them. Many football fans (including one I attended with) are liable to be disappointed with the `ultra-stylish' way Stone has decided to present the game.
In return, a three-star film becomes unfortunately degraded due to the director's tampering. In welcome scenes when the visual pummeling comes to a break, this actually shows decent character development and interaction. For instance, heated returns between D'Amato and feisty young owner Christina Pagniacci (Cameron Diaz) are enjoyable to watch. There is also a solid performance from Jamie Foxx, who experiments with great success in his first trek into dramatic territory. The stellar supporting cast includes Matthew Modine, Aaron Eckhart, Lauren Holly, Ann-Margret and Charlton Heston (in an extraordinarily brief appearance).
Pacino makes some interesting progress with his character. You begin to identify with coach D'Amato and the morals he is striving for.... but I often felt he was just another play thing Stone could weave in and out of his editing dynamics. `Any Given Sunday' is a watchable but disappointing sports film in which plot and characters take a back seat to excessive filmmaking technique. And a very distant back seat, at that.
(C) 1999, Jamey Hughton
* * * * * * * NEW Site Look - Logos/Buttons/Review & Homepage Designs "Best & Worst of '99" and More at: http://Welcome.to/MovieViews MOVIE VIEWS by Jamey Hughton * * * * * * * * * * * * * * * * * * * * *
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Team Members
Ashudeb Dutta
Key Member
Expertise in Radio Frequency VLSI chip design.
Gajendranath Chowdary
Key Member
Expertise in Ultra low power (VLSI chip design)
Shiv Govind Singh
Key Member
Expertise in VLSI sensor design.
Sobhan Babu
Key Member
Expertise in VLSI CAD.
Soumya Jana
Key Member
Expertise in Image processing
- Design Members
IITians


Spanish Law Enforcement Seized a Submarine Loaded with more than 2 Tonnes of Cocaine
Spanish law enforcement has seized a submarine that was loaded with more than 2 tonnes of cocaine, according to the El Pais.
Law enforcement officers have detained at least two people. The submarine was discovered in the waters of Galicia. It is believed that the submarine has arrived from Colombia. There are no other details so far.
According to Voz de Galicia, the submarine contained more than 3 tonnes of cocaine.