text stringlengths 454 608k | url stringlengths 17 896 | dump stringclasses 91
values | source stringclasses 1
value | word_count int64 101 114k | flesch_reading_ease float64 50 104 |
|---|---|---|---|---|---|
VB.NET Core Classes in a Nutshell
By
- Essential system and programming services found in the System namespace
- Text handling and regular expression pattern searches
- Diagnostics, debugging, and performance monitoring
- Generalized and specialized collection objects
- Reflection
- Extensible Markup Language (XML)
- Input/output and serialization
- Networking
- Threading and timers
- COM interop and globalization
Register your book | Submit Errata | About the CD-ROM
Browse within this book
| Table of Contents | Index | Sample Chapter | ColophonBook details
First Edition: June 2002
Series: In a Nutshell
ISBN: 0-596-00257-2
Pages: 576
Average Customer Reviews:
(5) (Based on 1 Reviews)
Featured customer reviews
great book, November 06 2006
Great book , the book explained the VB.NET classes flexible and easy way.
thanks alot for the authors and o'reilly team.
i hope more flexible in the next editions.
"A quick reference to the most essential classes in the .NET FCL. One thing that is unique about this book is the accompanying CD that enables readers to integrate the book's contents directly into the Dynamic Help inside Visual Studio .NET, thanks to a special partnership between O'Reilly and Microsoft."
--Janette Toral,, Oct 2002
"I have to admit I'm not that familiar with O'Reilly's In a Nutshell line of reference titles. But at the suggestion of Builder.com editor Tony Patton, I checked out 'VB.NET Core Classes in a Nutshell.' Now, I?m not sure how I ever got along without one of these reference manuals in my technical-book library...incredibly complete...Attached to the back cover, you?ll find an electronic version of the class documentation contained in the book. The CD, called 'VB.NET Core Classes in a Nutshell for Microsoft Visual Studio.NET,' can be installed as a help add-in to Visual Studio .NET. This electronic version almost exactly replicates the contents of the book, with the added convenience of hyperlinks to a class's documentation page each time the class is mentioned. My initial thinking was that the electronic version would simply be redundant information when combined with the MSDN documentation libraries. It turns out, however, that in add-in form, it's much more convenient than the mammoth HTML-Help MSDN documentation when you are attempting to locate a single class's description. It's better organized as well.... I'm so impressed with this book that I'd recommend it--along with any of O'Reilly?s other Nutshell titles--to anyone looking for a serious language reference book."--Lamont Adams, Builder.com, September 10, 2002 | http://oreilly.com/catalog/9780596002572/reviews.html | crawl-002 | refinedweb | 424 | 55.74 |
On 27.08.2013 22:51, Kishalmi László wrote:
> Well as subversion has no branches.
Sorry but I have to disagree. Subversion had no /copies/ that are not
branches. As far as node history and merging is concerned, /every/ copy
is a branch. Saying that Subversion has no branches is incorrect, and
making assumptions from that statement will lead to wrong conclusions.
Do not confuse the concept of a branch with the concept of a separate
namespace for branch names.
-- Brane
--
Branko Čibej | Director of Subversion
WANdisco // Non-Stop Data
e. brane_at_wandisco.com
This is an archived mail posted to the Subversion Users
mailing list. | https://svn.haxx.se/users/archive-2013-08/0529.shtml | CC-MAIN-2017-43 | refinedweb | 105 | 67.25 |
(Analysis by Jonathan Paulson - jonathanpaulson@gmail.com)
The main difficulty here is that $A$ and $B$ are so large we cannot consider each new cow separately. We have to batch them up somehow.
Imagine each cow as a point on a number line (corresponding to its weight). Each new cow has (at most) one neighbor to the left and one neighbor to the right, so either a new cow has one nearest neighbor, or it is exactly between two old cows.
So each old cow "covers" some range on the number line where it is the nearest neighbor, depending on the cow to it's left and right (i.e. the next lighter and next heavier cow). By counting up how many new cows each old spotted cow covers, we'll get our answer.
Coding this up is tough. There are a lot of possible off-by-one errors. In the rest of the analysis, I'll walk through how I coded it.
First off: the easiest way to consider a cow and it's neighbors at the same time is to sort them, so let's do that. A nice way to avoid edge cases is to add extra old cows at the beginning and the end so that each cow has two neighbors; if we put these extra cows far enough out, they won't affect anything.
I thought it was easiest to consider each neighboring pair of cows separately. Let $S$ (S for "start") be the weight of the cow on the left and let $E$ (E for "end") be the weight of the cow on the right. We want to handle the interval $[S+1, E]$ (notice we handle the right endpoint but not the left endpoint; this way, our ranges add up to the whole interval with no point counted twice or uncounted).
Let $M = \frac{S+E}{2}$ (M for "middle"). Then the left cow covers the interval $[S+1, M]$ and the right cow covers the interval $[M+1, E]$. But not every point is a new cow: we need to intersect these intervals with $[A, B]$. So really, the left cow covers the interval $[max(S+1, A), min(M, B)]$, and the right cow covers the interval $[max(M+1, A), min(E, B)]$. So if the left cow is spotted, add the left interval. If the right cow is spotted, add the right interval.
Whew! Actually, we've made one mistake: do you see it? We didn't consider the case where $M$ was right in the middle (if $S$ and $E$ are both even or both odd, $M$ is right in the middle; otherwise, $M$ is in the left interval where we put it). If $M$ is right in the middle, and the left cow is not spotted and the right cow is spotted *and* $M$ is a new cow, then we didn't count $M$ and we should have.
Here's my C++ code, which follows the description above closely:
#include <cstdio> #include <vector> #include <utility> #include <algorithm> #define PB push_back #define MP make_pair #define X first #define Y second using namespace std; typedef long long ll; typedef pair<ll, ll> pll; int main() { ll n, A, B; scanf("%lld %lld %lld", &n, &A, &B); vector<pll> V; for(ll i=0; i<n; i++) { char buf[100]; ll w; scanf("%s %lld", buf, &w); V.PB(MP(w, buf[0]=='S' ? 1 : 0)); } ll INF = ll(1000)*1000*1000*1000; V.PB(MP(-INF, 0)); V.PB(MP(INF, 0)); sort(V.begin(), V.end()); ll ans = 0; for(ll i=0; i+1<V.size(); i++) { ll S = V[i].X; ll E = V[i+1].X; ll M = (S+E)/2; if(V[i].Y==1) { ll s = max(A, S+1); ll e = min(B, M); if(e >= s) { ans += e-s+1; } } if(V[i+1].Y==1) { ll s = max(A, M+1); ll e = min(B, E); if(e >= s) { ans += e-s+1; } } if(V[i+1].Y==1 && V[i].Y==0 && (S%2)==(E%2) && A<=M && M<=B) { ans++; // Should count M } } printf("%lld\n", ans); } | http://usaco.org/current/data/sol_learning_bronze.html | CC-MAIN-2018-17 | refinedweb | 699 | 80.01 |
- Path
The Java
Path interface is part of the Java NIO 2 update which Java NIO received in Java 6 and Java 7.. A path can point to either a file or a directory.
A path can be absolute or relative. An absolute path contains the full path from the root of the file system down to the file or
directory it points to. A relative path contains the path to the file or directory relative to some other path.
Relative paths may sound a bit confusing. Don't worry. I will explain relative paths in more detail later in this
Java NIO Path tutorial.
Do not confuse a file system path with the
path environment variable in some operating systems. The
java.nio.file.Path interface has
nothing to do with the
path environment variable.
In many ways the
java.nio.file.Path interface is similar to the
java.io.File
class, but there are some minor differences. In many cases though, you can replace the use of the
File class
with use of the
Path interface.
Creating a Path Instance
In order to use a
java.nio.file.Path instance you must create a
Path instance. You
create a
Path instance using a static method in the
Paths class (
java.nio.file.Paths)
named
Paths.get(). Here is a Java
Paths.get() example:
import java.nio.file.Path; import java.nio.file.Paths; public class PathExample { public static void main(String[] args) { Path path = Paths.get("c:\\data\\myfile.txt"); } }
Notice the two
import statements at the top of the example. To use the
Path interface
and the
Paths class we must first import them.
Second, notice the
Paths.get("c:\\data\\myfile.txt") method call. It is the call to the
Paths.get()
method that creates the
Path instance. The
Paths.get() method is a factory method for
Path instances, in other words.
Creating an Absolute Path
Creating an absolute path is done by calling the
Paths.get() factory method with the absolute file
as parameter. Here is an example of creating a
Path instance representing an absolute path:
Path path = Paths.get("c:\\data\\myfile.txt");
The absolute path is
c:\data\myfile.txt. The double
\ characters are necessary in Java
strings, since the
\ is an escape character, meaning the following character tells what character is
really to be located at this place in the string. By writing
\\ you tell the Java compiler to write
a single
\ character into the string.
The above path is a Windows file system path. On a Unix system (Linux, MacOS, FreeBSD etc.) the above absolute path could look like this:
Path path = Paths.get("/home/jakobjenkov/myfile.txt");
The absolute path is now
/home/jakobjenkov/myfile.txt .
If you used this kind of path on a Windows machine (a path starting with
/) the path would be
interpreted as relative to the current drive. For instance, the path
/home/jakobjenkov/myfile.txt
could be interpreted as being located on the C drive. Then the path would correspond to this full path:
C:/home/jakobjenkov/myfile.txt
Creating a Relative Path
A relative path is a path that points from one path (the base path) to a directory or file. The full path (the absolute path) of a relative path is derived by combining the base path with the relative path.
The Java NIO
Path class can also be used to work with relative paths.
You create a relative path using the
Paths.get(basePath, relativePath) method. Here are two relative
path examples in Java:
Path projects = Paths.get("d:\\data", "projects"); Path file = Paths.get("d:\\data", "projects\\a-project\\myfile.txt");
The first example creates a Java
Path instance which points to the path (directory)
d:\data\projects.
The second example creates a
Path instance which points to the path (file)
d:\data\projects\a-project\myfile.txt
.
When working with relative paths there are two special codes you can use inside the path string. These codes are:
- .
- ..
The
. code means "current directory". For instance, if you create a relative path like this:
Path currentDir = Paths.get("."); System.out.println(currentDir.toAbsolutePath());
Then the absolute path the Java
Path instance corresponds to will be the directory in which the
application executing the above code is executed.
If the
. is used in the middle of a path string it just means the same directory as the path
was pointing to at that point. Here is an
Path example illustrating that:
Path currentDir = Paths.get("d:\\data\\projects\.\a-project");
This path will correspond to the path:
d:\data\projects\a-project
The
.. code means "parent directory" or "one directory up". Here is a
Path Java example
illustrating that:
Path parentDir = Paths.get("..");
The
Path instance created by this example would correspond to the parent directory of the directory
from which the application running this code was started.
If you use the
.. code in the middle of a path string it will correspond to changing one directory
up at that point in the path string. For instance:
String path = "d:\\data\\projects\\a-project\\..\\another-project"; Path parentDir2 = Paths.get(path);
The Java
Path instance created by this example will correspond to this absolute path:
d:\data\projects\another-project
The
.. code after the
a-project directory changes directory up the the parent
directory
projects and then the path references down into the
another-project directory
from there.
The
. and
.. codes also work in combination with the two-string
Paths.get()
method. Here are two Java
Paths.get() examples showing simple examples of that:
Path path1 = Paths.get("d:\\data\\projects", ".\\a-project"); Path path2 = Paths.get("d:\\data\\projects\\a-project", "..\\another-project");
There are more ways that the Java NIO
Path class can be used to work with relative paths. You will
learn more about that later in this tutorial.
Path.normalize()
The
normalize() method of the
Path interface can normalize a path. Normalizing means
that it removes all the
. and
.. codes in the middle of the path string, and resolves
what path the path string refers to. Here is a Java
Path.normalize() example:
String originalPath = "d:\\data\\projects\\a-project\\..\\another-project"; Path path1 = Paths.get(originalPath); System.out.println("path1 = " + path1); Path path2 = path1.normalize(); System.out.println("path2 = " + path2);
This
Path example first creates a path string with a
.. code in the middle. Then the example
creates a
Path instance from this path string, and prints that
Path instance out (actually
it prints
Path.toString()).
The example then calls
normalize() on the created
Path instance, which returns a new
Path instance. This new, normalized
Path instance is then also printed out.
Here is the output printed from the above example:
path1 = d:\data\projects\a-project\..\another-project path2 = d:\data\projects\another-project
As you can see, the normalized path does not contain the
a-project\.. part, as this is redundant.
The removed part adds nothing to the final absolute path. | http://tutorials.jenkov.com/java-nio/path.html | CC-MAIN-2017-13 | refinedweb | 1,166 | 60.11 |
This experimental project shows how to use ATtiny13 to synchronize live music and lights with only a few additional components required. Project uses single ADC (Analog to Digital Converter) channel for signal acquisition and some DSP (Digital Signal Processing) calculations that in real-time separate three frequency bands and make the LEDs dance in sync with the music. This project also proves that real-time DFT (Discrete Fourier Transformation) is possible on such small MCU like ATtiny13, which offers only 64B of RAM and 1024B of FLASH. Project doesn’t require any specific equipment and the parts costs are below 3$. The code is on Github, click here.
Project Overview
In this project ATtiny13 has a three major tasks: read audio signal, process signal and visualize frequency bands using LEDs. Simplified block diagram is presented bellow.
1. Audio Signal Acquisition (ADC, Signal Sampling)
The input signal source can be any audio signal. MCU uses ADC to read analog signal (signal acquisition) with required FS (Sampling Frequency). This phase produces N signal samples – discrete signal in the time domain.
2. Signal Processing (DFT)
Next, signals are converted from time domain form to the frequency domain using a DFT algorithm. The product of that phase is N values that represents amplitudes of N frequencies, where particular frequency is, F(n) = FS/N. Because of the Nyquist frequency rule, which is a property of a discrete-time system, we can use only N/2 of samples for further signal analysis. Please note, that to simplify algorithm complexity, only a real part of complex numbers has been used.
3. LEDs Visualization (PWM)
At last, MCU put some visualisation based on information from previous phase. Each LED represents a frequency bandwidth. MCU checks all frequency amplitudes, and by toggling LEDs It simulates Software PWM, what in result gives quite good control of LED brightness.
Top Project Challenges
1. DSP calculations require real numbers what consumes a lot of ATtiny13 resources
Calculations on float/double take much of RAM, CPU time and FLASH space. It was a critical issue for the project realization. Solution was to make it possible to replace all real numbers by integers.
2. FFT algorithms require a lot of RAM, more than offers ATtiny13
Eliminations of real numbers was a good optimization trick but still, It was not possible to implement efficient algorithm. Solution was, adding precalculated twiddle factors for 6-point DFT, using array of short integers and focusing on calculations only for real part of complex numbers (sic!). In result 31 bytes (48.4%) of RAM has been reserved for arrays and 33 bytes (51.6%) was left to use by program.
For some smartasses that are interested in why twiddle factors are stored not in PROGMEM but in RAM. It’s an optimization. Accessing data from RAM is a bit faster as it takes extra steps to get data from PROGMEM. For more information click here.
3. FFT algorithms require more space than offers ATtiny13
Popular implementations of FFT (Fast Fourier Transformation) require more program space then offers ATtiny13. It’s worth to note, that originally, algorithm was designed to do calculation for both parts of complex numbers and calculate a signal power as a product for next phase. However, it require ~20% more program space and >50% more RAM. Solution was, combaine some features of naive version – it is DFT with precalculated twiddle factors using in FFT algorithms and do calculation for only real part of complex numbers what is good enough, as for this project. In result program size is ~464 bytes (45.3%).
Parts List
- ATtiny13 – i.e. MBAVR-1 (Minimalist Development Board)
- R1, R2, R3 – resistor 560Ω, see LED Resistor Calculator
- R4 – trimm 10kΩ
- R5 – resistor 100kΩ
- LED1, LED2, LED3 – red, green and blue (or other colours of your preference) LEDs8 * Dance lights with simplified DFT (Discrete Fourier Transformation) * -- * Settings: * FUSE_L=0x6A * FUSE_H=0xFF * F_CPU=1200000 */ #include <avr/io.h> #include <util/delay.h> #include <avr/interrupt.h> #define LED_RED PB0 #define LED_GREEN PB1 #define LED_BLUE PB2 #define BASS_THRESHOLD (300) #define MIDRANGE_THRESHOLD (40) #define TREBLE_THRESHOLD (30) #define N (6) const int8_t W[N] = {10, 4, -5, -9, -4, 5}; int16_t samples[N] = {0}; int16_t re[N]; volatile uint8_t acquisition_cnt = 0; ISR(ADC_vect) { uint8_t high, low; if (acquisition_cnt < N) { low = ADCL; high = ADCH; samples[acquisition_cnt] = (high << 8) | low; acquisition_cnt++; ADCSRA |= _BV(ADSC); } } static void dft(void) { uint8_t a, k, n; for (k = 0; k < N; ++k) re[k] = 0; for (k = 0; k <= (N>>1); ++k) { a = 0; for (n = 0; n < N; ++n) { re[k] += W[a%N] * samples[n]; a += k; } if (re[k] < 0) re[k] = -(re[k] + 1); } } int main(void) { /* setup */ DDRB |= _BV(LED_BLUE)|_BV(LED_GREEN)|_BV(LED_RED); // set LED pins as OUTPUT ADCSRA |= _BV(ADPS2)|_BV(ADPS1); // set ADC division factor 64; ADCSRA |= _BV(ADEN)|_BV(ADIE); // ADC interrupt enable ADMUX = _BV(MUX1); // set PB4 as audio input sei(); // enable global interrupts ADCSRA |= _BV(ADSC); // Start first signal acquisition /* loop */ while (1) { if (acquisition_cnt == N) { dft(); /* LED BLUE - Bass */ if (re[0] > BASS_THRESHOLD) { PORTB |= _BV(LED_BLUE); } else { PORTB &= ~_BV(LED_BLUE); } /* LED GREEN - Midrange */ if (re[1] > MIDRANGE_THRESHOLD) { PORTB |= _BV(LED_GREEN); } else { PORTB &= ~_BV(LED_GREEN); } /* LED RED - Treble */ if (re[2] > TREBLE_THRESHOLD) { PORTB |= _BV(LED_RED); } else { PORTB &= ~_BV(LED_RED); } /* Trigger next signal acquisition */ acquisition_cnt = 0; ADCSRA |= _BV(ADSC); } } }
11 thoughts on “ATtiny13 – dance lights with DFT”
can you explain the code brother?
Hi,
Which microphone was used in this project? I’m using KY-038 sensor to input the audio but so far the LEDs don’t react like in the video. Is this microphone sufficient for the project? Would you suggest amplification?
Hi, the project was tested with headphone audio output from my computer but you can use electret microphone and LM358 as amplifier.
/L
Hi! Just made this Dance Lights with FFT…. in “Stereo Vision” LOVED IT! and placed it beside my LM3916 VU meter project. Thanks for sharing the code and schematics!
Currently you get a kind of PWM linked to your threshold, what do you think about using TCCR0A and TCCR0B and set up a true pwm ? ( Attiny861 has 3 PWM ).
I guess it would be nice with some kind of log(re[n] ) and scaling before setting PWM ?
Have you seen this ?
( It would be nice selecting number of points, when you have more ram 😉
My goal is to create a 100+ projects on ATtiny13. On other chips with more RAM and/or PWM channels, a lot of improvements could be done in easy way. However, this one with “scaling effect” can be implemented using Software PWM, as well.
Regarding current algorithm and calculations for more points. Before I started this project I’ve produce some materials and scripts in order to make a simulations on local machine. I think it will be a part of other post, soon. But as for now – bellow you can find a python code that calculates Twiddle Factors of declared N what is the only required thing to extend the number of points on this project.
import math
N = 6
PI2 = 6.2832
# Calc twiddle factors
W = [math.cos(n*PI2/N) for n in range(N)]
# Convert W to list of integers
I = [int(n * 10) for n in W]
print("Twiddle Factors: {}".format(I))
nice ! thanks !
fix_fft seems to work with int8_t, maybe you could save like 15 bytes 😉
My guess is you are close or equal to these with a lot less code
>ADCSRA |= _BV(ADPS2)|_BV(ADPS1); // set ADC division factor 64;
>F_CPU=9600000
Are you sampling ADC with 150kHz ? and if so why ?
( I plan to run it on the default 1MHz )
A fun twist of your code would be to put it inside a flash-light driver.
It is an impressive project and works good obviously. I was wondering, if a discrete cosine transformation DCT (or FCT) as used in jpeg compression could do same with less recources. Since you are dropping the imaginary numbers.
Yes, since I’m using only a real signal for calculation, the DCT would work here. Very good tip. Thank you!
ref: | https://blog.podkalicki.com/attiny13-dance-lights-with-dft/ | CC-MAIN-2020-40 | refinedweb | 1,353 | 61.87 |
In traditional ASP code reuse and encapulation was traditionally done
using a combination of include files and web classes. While this worked
reasonably well for business logic, it was always a little fiddly for visual
components. For example, if you wanted to display a grid of data in many
different places and have the grid have the same general look and feel, but be
customisable for a particular page, then you either cut and pasted the HTML,
used style sheets, used an include file, wrote some VBScript to generate the
HTML on the fly, or used a combination of all these methods.
It was messy. It could also be difficult to move these components between
projects because there was the ever present problem of ensuring that variable
names didn't conflict, that you had the include file included only once
(and in the correct order). Then there was the whole issue of tying the new
control into existing code.
ASP .NET solves many of these issues with the introduction of User
Controls. These are self contained visual elements that can be placed on a web
page in the same way as a tradition intrinsic HTML control, and can have their
attributes set in a similar fashion.
In this article I'll present a Title bar that has 6 properties (border width
and colour, Title text and colour, background and padding. The control is
embedded in a page using the following simple syntax:
<CP:TitleBar
This produces the following output:
The easiest way is using Visual Studio .NET. Start a new
web project and right click on the project's name in the Server Explorer. Select
'Add...' then 'Add Web User Control...' Rename the control and hit Open. The
wizard produces two files: a .ascx file containing the visual layout, and a
.ascx.cs (assuming you are working in C#) that has the business logic.
First we design the visual layout of the Title bar. We'll use the new asp:XXX
controls so that we get simple access to their attributes at runtime.
The entire .ascx file looks like:
<%@ Control Language="c#" AutoEventWireup="false"
Codebehind="MyUserControl.ascx.cs"
Inherits="CodeProject.MyUserControl"
TargetSchema=""%>
<asp:table id=OuterTable BackColor=#c0c0c0c BorderWidth=0 cellPadding=0
cellSpacing=1
<asp:tableRow><asp:tableCell
<asp:table id=InnerTable BackColor=#cccccc BorderWidth=0 cellPadding=0
cellSpacing=1
<asp:tableRow<asp:tablecell HorizontalAlign=Center>
<asp:Label ID=TitleLabel
</asp:tablecell></asp:tableRow>
</asp:table>
</asp:tablecell></asp:tableRow>
</asp:table>
A fairly traditional way of creating a table with a thin
border - except that we are using ASP .NET controls instead of traditional HTML.
Note that if you were restricting your viewers to using IE then you could use
the border-width style to set the border style and stick with one table.
However, if you have Netscape 4.X viewers then this won't work. ASP .NET
controls will output HTML 3.2 for downspec browsers like Netscape, so while ASP
.NET's promise of 'write-once, view anywhere' sounds good, it doesn't actually
happen in practice.
I'm not going to go into the in's and out's of ASP .NET
controls. They are fairly self explanatory. Just make sure you include the
'runat=server' bit. They help.
Note the bit up the top of the file: Codebehind="MyUserControl.ascx.cs".
This is where the visual layout (.ascx file) is hooked up with the backend logic
(.ascx.cs). We will barely scrape the surface of what this separation of logic
and display can do.
Codebehind="MyUserControl.ascx.cs"
Our C# code looks like the following:
namespace CodeProject
{
using System;
...
public abstract class MyUserControl : System.Web.UI.UserControl
{
public string Title = null;
public string TextColor = Color.Black.Name;
public string BackColor = Color.Wheat.Name;
public int Padding = 2;
public string BorderColor = Color.Gray.Name;
public int BorderWidth = 1;
protected Table OuterTable;
protected Table InnerTable;
protected Label TitleLabel;
private void Page_Load(object sender, System.EventArgs e)
{");
}
}
#region Web Form Designer generated code
...
#endregion
}
}
The entire purpose of this backend is to define a set of properties
that the user can access when instantiating the control, and to then
set the attributes of the ASP .NET controls in our .ascx file based on
these properites.
We could just as easily open a connection to a database and bind
a dataset to a control, or we could access the page that this control
resides in (using the Page property) and adjust the look
and feel of the control from what we find there. We could also provide
user input mechanisms in our display and provide handlers for click
events in the control here as well. These controls really are quite powerful.
Page
Unfortunately we'll be staying a lot closer to Earth and
will only provide the mediocrity of colour and border width changes.
Note the block of variable declarations at the top:
public string Title = null;
public string TextColor = Color.Black.Name;
public string BackColor = Color.Wheat.Name;
public int Padding = 2;
public string BorderColor = Color.Gray.Name;
public int BorderWidth = 1;
These publicly accessible variables form the attributes that are
available to the user when he or she instantiates the control in a
web page:
<CP:TitleBar
The user can set all, some or none of these properties.
The other half of the story is the link between the ASP .NET controls
and the C# code. Note the block of variables underneath these:
protected Table OuterTable;
protected Table InnerTable;
protected Label TitleLabel;
The names of these variables are the same as the ID's of the ASP .NET controls
in our .ascx page. This causes the variable in our C# class to be linked up to the
ASP .NET control in the .ascx page. We can now manipulate the controls on the
page however we like:");
}
Here we simply check if there is any title text, and if not then we set the
control as invisible (meaning the HTML for the control simply won't be rendered
and will not be sent down to the client). If there is text then we go ahead and
set the properties of the controls.
And we're done!
To use the control you will first need to compile the project with your files,
and then create a page to host the control. The code for the control will be compiled
into an assembly and placed in the /bin directory. If you make any changes to the
C# code you'll need to recompile. You do not have to recompile if you make changes
to the visual layout (.ascx) file.
To use the control you must make a page aware of the control. We do this
by using a Register directive that specified the tag prefix we'll use, the
tag name and the location of the user control's page:
<%@ Register TagPrefix="CP" TagName="TitleBar" Src="MyUserControl.ascx" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<html>
<head>
<title>MyPage</title>
</head>
<body>
<basefont face=verdana>
<CP:TitleBar
</body>
</html>
The tag prefix in this case is CP, and the tag TitleBar They can be anything you want as long as there are no conflicts. Open the page in your browser and be amazed at your cleverness.
CP
Title | http://www.codeproject.com/script/Articles/View.aspx?aid=1739 | CC-MAIN-2014-10 | refinedweb | 1,212 | 63.8 |
functools Module
In this lesson, you’ll learn about the
functools module. This module contains some useful higher order functions like
reduce() and some decorators like
cached_property and
lru_cache.
functools.reduce() is useful to apply a function over and over on an iterable to “reduce” it to one single value:
>>> from functools import reduce >>> reduce(lambda x, y: x * y, [1, 2, 3, 4]) 24
functools.cached_property is available in Python 3.8 and above and allows you to cache class properties. Once a property is evaluated, it won’t be evaluated again.
functools.lru_cache allows you to cache recursive function calls in a least recently used cache. This can optimize functions with multiple recursive calls like the Fibonnacci sequence.
You can check out the Python documentation on the
functools module.
00:00
In this video, you’ll learn about the
functools module and learn about one higher order function
reduce() and two decorators,
cached_property and
lru_cache. Let’s get started with
reduce()—
from functools import reduce.
00:13
reduce() is a function that helps us combine, or reduce, a iterable into one value. For example,
reduce() of
lambda—a two-argument
lambda—
x + y, a list of
00:27
[1, 2, 3, 4].
10. So, what happened there is it did
1 + 2,
00:36
and then did that value
+ 3, and then did that value
+ 4.
00:45
Let’s do one more example. Multiply and then pass in an initial value
10. So, that did
10 * 1—whatever the result is there
* 1,
* 3, and
* 4.
01:04
It’s important to include those parentheses to show that it actually evaluates left to right. It doesn’t evaluate just all at once. So, in an interview, if the interviewer asks you to somehow combine a list into one value, according to some rules, then
functools.reduce() should come to mind.
01:20
Let’s move on to the decorators. Let’s pretend we have a
Data class that takes in an
__init__(self, n).
self.n = n, and then let’s define a
@property which is
def f(self) and does something that takes a long time. So, maybe
total = 0
for i in range(self.n):
for j in range(self.n):
for k in range(self.n):
total += i + j + k.
01:53
Then,
return total. Let’s load the function interactively using IPython.
01:59
d = Data(200),
d.f,
d.f. It’s evaluating this n-cubed function over and over again. Notice how this function doesn’t actually have any side effects, and so we can actually cache this value by using the
cached_property decorator.
02:17
from functools import cached_property. Note, this will only work in Python 3.8 and above, and that’s why my VS Code is yelling at me, because I think that VS Code linter is using Python 3.7.
02:30
Same with IPython—I set it up to use Python 3.7, and so instead I’ll use Python 3.8, and I also replaced the word
@property with
@cached_property. Let’s try it.
02:40
d = Data(200),
d.f takes a little while—but now, it’s instant! There’s also a
pip package
cached-property that does the same thing, and you can use it in versions before Python 3.8.
02:52
Let’s move on to another cached decorator. Imagine you’re writing the Fibonacci function. So, the Fibonacci series looks something like this. The zeroth at the Fibonacci number is
0, the first Fibonacci is
1, the next Fibonacci number is the previous two added together, and so on.
03:09
So, the next one would be 1 + 1, 2 + 1, 3 + 2, et cetera. This is a very natural recursive function. Our base case would be
if n <= 1
return n, otherwise,
return fib(n - 1) + fib(n - 2).
03:31
Save it, run it interactively. Let’s just run it with Python 3.8, so the import at the top doesn’t error.
fib(5)?
5.
fib(10)?
55.
fib(100)? Takes a long time.
03:47
Let’s see why it’s taking a long time. You can
print(n),
03:53
run this,
fib(5). Notice how
fib(5) actually called
fib(4) and
fib(3).
04:06
fib(4) called
fib(3) and
fib(2). This call also called
fib(2) and
fib(1).
04:16
fib(3) called
fib(2), called
fib(1), and this one called
fib(1) and
fib(0), et cetera. It’s sort of like a tree. It’s splitting by two calls each time.
04:26
You can imagine
fib(100) is doing a lot of duplicate work. This is where the
lru_cache comes in.
from functools import lru_cache.
04:36
This is available in Python 3.2 and above. Wrap our function in
@lru_cache, save, exit. Now, when you call
fib(5), it actually caches those values, and then when you have to access it later on, it can access it immediately. So,
fib(100)—now, it takes a lot faster. And notice how, here, it actually stopped printing out after
6, because
5 through
1 were actually already cached, here.
05:06
That concludes the
functools video. As always, there are many more functions included in the module and I’ll link the documentation down below. In the next video, you’ll learn about the
doctest module and
assert statements.
Sorry wrong link:
Here is the Python documentation on the
functools module: Python functools module
Become a Member to join the conversation.
James Uejio RP Team on April 27, 2020
Here is the Python documentation on the
itertoolsmodule: Python itertools module | https://realpython.com/lessons/functools-module/ | CC-MAIN-2020-40 | refinedweb | 955 | 77.13 |
What would be the best place to gather basic metrics?
We have multiple implementations spanning many namespaces and edges. I would like to see if I could identify a single place, perhaps on HSREGISTRY or HSBUS, that I could capture certain events like searches (from all customers) and record transfers (with requester and provider).
The goal is to have a dashboard that would show simple stats such as searches by participant, records shared by participant and records consumed by participant. These are the 3 most important.
I appreciated the feedback on the other question of "how" but now I'm hoping to find the "Where". | https://community.intersystems.com/post/what-would-be-best-place-gather-basic-metrics | CC-MAIN-2022-05 | refinedweb | 105 | 70.84 |
Search
or
Ask a new question
Unlimited access to over 2.5 million step-by-step Chegg textbook solutions.
Ask questions around the clock, get fast answers.
PAST ASSIGNMENT
#include using namespace std; class Button { private: int
pressCount;/
Given the three sets A, B, and C. Suppose the union of the three
sets has a cardinality of 280. Su
For these Exercises, describe the output produced, assume that
i, j, and k are of type int. Trace th
0For these Exercises, describe the output produced, assume that
i, j, and k are of type int. Trace t
A new comparison based sorting algorithm makes at most n
comparisons to sort a list L of length n. H
How could I apply multiple input validations in my program? I
want to add something like this "el
A system admin has a set of n jobs which need to be run, and
each job requires processing in three s
A small restaurant faces the following scheduling problem. Each
morning n customers arrive at the re
Let X be a discrete random variable with a probability mass
function p given by:
a -1 0 1 2
I need to write a program todetermine whether a date is valid,
invalid,or a valid leap year. Any
import java.io.*;
import org.xml.sax.*;
import org.xml.sax.helpers.*;
import javax.xml.parser
write a program that calculate the speed of sound (a) in air of
a given temperature t (f) formula to
Show the value of the register and the carry after the execution
of the following instruction.
Please provide complete code including any driver classes
associated with the program. You can use p
I am stuck with my Java Arrays program. I am supposed to create
a program that allows the user to 1) | http://www.chegg.com/homework-help/questions-and-answers/computer-science-archive-2013-february-08 | CC-MAIN-2013-20 | refinedweb | 301 | 61.56 |
This very nice idea is from rantos22's solution who sadly only commented "You are not expected to understand that :)", which I guess is the reason it's now it's hidden among the most downvoted solutions. I present an explanation and a more usual implementation.
Explanation
Let's say
nums looks like this: [12, 13, 14, 15, 16, 17, 18, 19, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
Because it's not fully sorted, we can't do normal binary search. But here comes the trick:
If target is let's say 14, then we adjust
numsto this, where "inf" means infinity:
[12, 13, 14, 15, 16, 17, 18, 19, inf, inf, inf, inf, inf, inf, inf, inf, inf, inf, inf, inf]
If target is let's say 7, then we adjust
numsto this:
[-inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
And then we can simply do ordinary binary search.
Of course we don't actually adjust the whole array but instead adjust only on the fly only the elements we look at. And the adjustment is done by comparing both the target and the actual element against nums[0].
Code
If
nums[mid] and
target are "on the same side" of
nums[0], we just take
nums[mid]. Otherwise we use -infinity or +infinity as needed.
int search(vector<int>& nums, int target) { int lo = 0, hi = nums.size(); while (lo < hi) { int mid = (lo + hi) / 2; double num = (nums[mid] < nums[0]) == (target < nums[0]) ? nums[mid] : target < nums[0] ? -INFINITY : INFINITY; if (num < target) lo = mid + 1; else if (num > target) hi = mid; else return mid; } return -1; }
Java version
public int search(int[] nums, int target) { int lo = 0, hi = nums.length - 1; while (lo <= hi) { int mid = lo + (hi - lo) / 2; int num = nums[mid]; // If nums[mid] and target are "on the same side" of nums[0], we just take nums[mid]. if ((nums[mid] < nums[0]) == (target < nums[0])) { num = nums[mid]; } else { num = target < nums[0] ? Integer.MIN_VALUE : Integer.MAX_VALUE; } if (num < target) lo = mid + 1; else if (num > target) hi = mid - 1; else return mid; } return -1; }
Inspired by this and @StefanPochmann work here:
We can also view the array as already sorted with the following transformation:
tuple: (value less than nums[0]?, value) [1,2,3,4,5] -> [(0,1), (0,2), (0,3), (0,4), (0,5)] [5,1,2,3,4] -> [(0,5), (1,1), (1,2), (1,3), (1,4)]
Then we can use our standard binary search like so:
def search(self, nums, target): N, t = nums, target i = bisect.bisect_left([(x < N[0], x) for x in N], (t < N[0], t)) return i if t in N[i:i+1] else -1
But that's already O(n) for the transform so ...:
def search(self, nums, target): lo, hi, t = 0, len(nums) - 1, (target < nums[0], target) while lo <= hi: mid = (lo + hi) // 2 guess = (nums[mid] < nums[0], nums[mid]) if guess == t: return mid elif guess < t: lo = mid + 1 else: hi = mid - 1 return -1
Rewrite Stefan's algorithm in Java. Hope to make it a little simpler without losing its beauty.
public int search(int[] nums, int target) { int n = nums.length; if (n == 0) return -1; int lo = 0, hi = n - 1, mid = 0, num = 0; while (lo <= hi) { mid = (lo + hi) >> 1; if (nums[mid] == target) return mid; if ((nums[mid] < nums[0]) ^ (target < nums[0])) nums[mid] = target < nums[0]? Integer.MIN_VALUE : Integer.MAX_VALUE; if (nums[mid] < target) lo = mid + 1; else hi = mid - 1; } return -1; }
@zzhai said in Clever idea making it simple:
if ((nums[mid] < nums[0]) ^ (target < nums[0]))
Great idea to use ^
Is there an assumption that the array doesn't contain repeated numbers? If the given array is [9, 2, 9, 9, 9, 9, 9] and the target is 2, this algorithm returns -1.
@da.lin.1232 Hello,
If we we are looking for Integer.MAX_VALUE, the result is wrong.
I think Long is required.
@StefanPochmann Thanks for the explanation! It makes sense.
I translated your code to python, but it doesn't seem to work (fails on case [3,1]
,3) Could you see why? Here's my code:
def search(self, nums, target): low = 0 high = len(nums) while low < high: #middle = low + (high - low)/2 middle = (low + high) / 2 current = nums[middle] if (nums[middle] > nums[0])==(target > nums[0]) else (-float('inf') if target < nums[0] else float('inf')) if current < target: low = middle + 1 elif current > target: high = middle else: return middle return -1
Thanks.
@yujiehuang get rid of else statement and insert the following right after you initialize middle--->
if nums[middle]==target:return middle
Looks like your connection to LeetCode Discuss was lost, please wait while we try to reconnect. | https://discuss.leetcode.com/topic/34491/clever-idea-making-it-simple | CC-MAIN-2017-51 | refinedweb | 826 | 64.75 |
This tutorial depends on step-49.
This program was contributed by Wolfgang Bangerth and Luca Heltai, using data provided by D. Sarah Stamps.
Partial differential equations for realistic problems are often posed on domains with complicated geometries. To provide just a few examples, consider these cases:
This program is therefore devoted to showing how one deals with complex geometries using a concrete application. In particular, what it shows is how we make a mesh fit the domain we want to solve on. On the other hand, what the program does not show is how to create a coarse for a domain. The process to arrive at a coarse mesh is called "mesh generation" and there are a number of high-quality programs that do this much better than we could ever implement. However, deal.II does have the ability to read in meshes in many formats generated by mesh generators and then make them fit a given shape, either by deforming a mesh or refining it a number of times until it fits. The deal.II Frequently Asked Questions page referenced from provides resources to mesh generators.
Let us assume that you have a complex domain and that you already have a coarse mesh that somehow represents the general features of the domain. Then there are two situations in which it is necessary to describe to a deal.II program the details of your geometry:
In both cases, we need a way to provide information about the geometry of the domain at the level of an individual cell, its faces and edges. This is where the Manifold class comes into play. Manifold is an abstract base class that only defines an interface by which the Triangulation and Mapping classes can query geometric information about the domain. Conceptually, Manifold sees the world in a way not dissimilar to how the mathematical subdiscipline geometry sees it: a domain is essentially just a collection of points that is somehow equipped with the notion of a distance between points so that we can obtain a point "in the middle" of some other points.
deal.II provides a number of classes that implement the interface provided by Manifold for a variety of common geometries. On the other hand, in this program we will consider only a very common and much simpler case, namely the situation where (a part of) the domain we want to solve on can be described by transforming a much simpler domain (we will call this the "reference domain"). In the language of mathematics, this means that the (part of the) domain is a chart. Charts are described by a smooth function that maps from the simpler domain to the chart (the "push-forward" function) and its inverse (the "pull-back" function). If the domain as a whole is not a chart (e.g., the surface of a sphere), then it can often be described as a collection of charts (e.g., the northern hemisphere and the southern hemisphere are each charts) and the domain can then be describe by an atlas.
If a domain can be decomposed into an atlas, all we need to do is provide the pull-back and push-forward functions for each of the charts. In deal.II, this means providing a class derived from ChartManifold, and this is precisely what we will do in this program.
To illustrate how one describes geometries using charts in deal.II, we will consider a case that originates in an application of the ASPECT mantle convection code, using a data set provided by D. Sarah Stamps. In the concrete application, we were interested in describing flow in the Earth mantle under the East African Rift, a zone where two continental plates drift apart. Not to beat around the bush, the geometry we want to describe looks like this:
In particular, though you cannot see this here, the top surface is not just colored by the elevation but is, in fact, deformed to follow the correct topography. While the actual application is not relevant here, the geometry is. The domain we are interested in is a part of the Earth that ranges from the surface to a depth of 500km, from 26 to 35 degrees East of the Greenwich meridian, and from 5 degrees North of the equator to 10 degrees South.
This description of the geometry suggests to start with a box \(\hat U=[26,35]\times[-10,5]\times[-500000,0]\) (measured in degrees, degrees, and meters) and to provide a map \(\varphi\) so that \(\varphi^{-1}(\hat U)=\Omega\) where \(\Omega\) is the domain we seek. \((\Omega,\varphi)\) is then a chart, \(\varphi\) the pull-back operator, and \(\varphi^{-1}\) the push-forward operator. If we need a point \(q\) that is the "average" of other points \(q_i\in\Omega\), the ChartManifold class then first applies the pull-back to obtain \(\hat q_i=\varphi(q_i)\), averages these to a point \(\hat p\) and then computes \(p=\varphi^{-1}(\hat p)\).
Our goal here is therefore to implement a class that describes \(\varphi\) and \(\varphi^{-1}\). If Earth was a sphere, then this would not be difficult: if we denote by \((\hat \phi,\hat \theta,\hat d)\) the points of \(\hat U\) (i.e., longitude counted eastward, latitude counted northward, and elevation relative to zero depth), then
\[ \mathbf x = \varphi^{-1}(\hat \phi,\hat \theta,\hat d) = (R+\hat d) (\cos\hat \phi\cos\hat \theta, \sin\hat \phi\cos\hat \theta, \sin\hat \theta)^T \]
provides coordinates in a Cartesian coordinate system, where \(R\) is the radius of the sphere. However, the Earth is not a sphere:
It is flattened at the poles and larger at the equator: the semi-major axis is approximately 22km longer than the semi-minor axis. We will account for this using the WGS 84 reference standard for the Earth shape. The formula used in WGS 84 to obtain a position in Cartesian coordinates from longitude, latitude, and elevation is
\[ \mathbf x = \varphi_\text{WGS84}^{-1}(\phi,\theta,d) = \left( \begin{array}{c} (\bar R(\theta)+d) \cos\phi\cos\theta, \\ (\bar R(\theta)+d) \sin\phi\cos\theta, \\ ((1-e^2)\bar R(\theta)+d) \sin\theta \end{array} \right), \]
where \(\bar R(\theta)=\frac{R}{\sqrt{1-(e \sin\theta)^2}}\), and radius and ellipticity are given by \(R=6378137\text{m}, e=0.081819190842622\). In this formula, we assume that the arguments to sines and cosines are evaluated in degree, not radians (though we will have to change this assumption in the code).
\[ (\phi,\theta,d) = \varphi_\text{topo}^{-1}(\hat\phi,\hat\theta,\hat d) = \left( \hat\phi, \hat\theta, \hat d + \frac{\hat d+500000}{500000}h(\hat\phi,\hat\theta) \right). \]Using this function, the top surface of the box \(\hat U\) is displaced to the correct topography, the bottom surface remains where it was, and points in between are linearly interpolated.
Using these two functions, we can then define the entire push-forward function \(\varphi^{-1}: \hat U \rightarrow \Omega\) as
\[ \mathbf x = \varphi^{-1}(\hat\phi,\hat\theta,\hat d) = \varphi_\text{WGS84}^{-1}(\varphi_\text{topo}^{-1}(\hat\phi,\hat\theta,\hat d)). \]
In addition, we will have to define the inverse of this function, the pull-back operation, which we can write as
\[ (\hat\phi,\hat\theta,\hat d) = \varphi(\mathbf x) = \varphi_\text{topo}(\varphi_\text{WGS84}(\mathbf x)). \]
We can obtain one of the components of this function by inverting the formula above:
\[ (\hat\phi,\hat\theta,\hat d) = \varphi_\text{topo}(\phi,\theta,d) = \left( \phi, \theta, 500000\frac{d-h(\phi,\theta)}{500000+h(\phi,\theta)} \right). \]
Computing \(\varphi_\text{WGS84}(\mathbf x)\) is also possible though a lot more awkward. We won't show the formula here but instead only provide the implementation in the program.
There are a number of issues we need to address in the program. At the largest scale, we need to write a class that implements the interface of ChartManifold. This involves a function
push_forward() that takes a point in the reference domain \(\hat U\) and transform it into real space using the function \(\varphi^{-1}\) outlined above, and its inverse function
pull_back() implementing \(\varphi\). We will do so in the
AfricaGeometry class below that looks, in essence, like this:
The transformations above have two parts: the WGS 84 transformations and the topography transformation. Consequently, the
AfricaGeometry class will have additional (non-virtual) member functions
AfricaGeometry::push_forward_wgs84() and
AfricaGeometry::push_forward_topo() that implement these two pieces, and corresponding pull back functions.
The WGS 84 transformation functions are not particularly interesting (even though the formulas they implement are impressive). The more interesting part is the topography transformation. Recall that for this, we needed to evaluate the elevation function \(h(\hat\phi,\hat\theta)\). There is of course no formula for this: Earth is what it is, the best one can do is look up the altitude from some table. This is, in fact what we will do.
The data we use was originally created by the Shuttle Radar Topography Mission, was downloaded from the US Geologic Survey (USGS) and processed by D. Sarah Stamps who also wrote the initial version of the WGS 84 transformation functions. The topography data so processed is stored in a file
topography.txt.gz that, when unpacked looks like this:
The data is formatted as
latitude longitude elevation where the first two columns are provided in degrees North of the equator and degrees East of the Greenwich meridian. The final column is given in meters above the WGS 84 zero elevation.
In the transformation functions, we need to evaluate \(h(\hat\phi,\hat\theta)\) for a given longitude \(\hat\phi\) and latitude \(\hat\theta\). In general, this data point will not be available and we will have to interpolate between adjacent data points. Writing such an interpolation routine is not particularly difficult, but it is a bit tedious and error prone. Fortunately, we can somehow shoehorn this data set into an existing class: Functions::InterpolatedUniformGridData . Unfortunately, the class does not fit the bill quite exactly and so we need to work around it a bit. The problem comes from the way we initialize this class: in its simplest form, it takes a stream of values that it assumes form an equispaced mesh in the \(x-y\) plane (or, here, the \(\phi-\theta\) plane). Which is what they do here, sort of: they are ordered latitude first, longitude second; and more awkwardly, the first column starts at the largest values and counts down, rather than the usual other way around.
Now, while tutorial programs are meant to illustrate how to code with deal.II, they do not necessarily have to satisfy the same quality standards as one would have to do with production codes. In a production code, we would write a function that reads the data and (i) automatically determines the extents of the first and second column, (ii) automatically determines the number of data points in each direction, (iii) does the interpolation regardless of the order in which data is arranged, if necessary by switching the order between reading and presenting it to the Functions::InterpolatedUniformGridData class.
On the other hand, tutorial programs are best if they are short and demonstrate key points rather than dwell on unimportant aspects and, thereby, obscure what we really want to show. Consequently, we will allow ourselves a bit of leeway:
All of this then calls for a class that essentially looks like this:
Note how the
value() function negates the latitude. It also switches from the format \(\phi,\theta\) that we use everywhere else to the latitude-longitude format used in the table. Finally, it takes its arguments in radians as that is what we do everywhere else in the program, but then converts them to the degree-based system used for table lookup. As you will see in the implementation below, the function has a few more (static) member functions that we will call in the initialization of the
topography_data member variable: the class type of this variable has a constructor that allows us to set everything right at construction time, rather than having to fill data later on, but this constructor takes a number of objects that can't be constructed in-place (at least not in C++98). Consequently, the construction of each of the objects we want to pass in the initialization happens in a number of static member functions.
Having discussed the general outline of how we want to implement things, let us go to the program and show how it is done in practice.
Let us start with the include files we need here. Obviously, we need the ones that describe the triangulation (
tria.h), and that allow us to create and output triangulations (
grid_generator.h and
grid_out.h). Furthermore, we need the header file that declares the Manifold and ChartManifold classes that we will need to describe the geometry (
manifold.h). We will then also need the GridTools::transform() function from the last of the following header files; the purpose for this function will become discussed at the point where we use it.
The remainder of the include files relate to reading the topography data. As explained in the introduction, we will read it from a file and then use the Functions::InterpolatedUniformGridData class that is declared in the first of the following header files. Because the data is large, the file we read from is stored as gzip compressed data and we make use of some BOOST-provided functionality to read directly from gzipped data.
The last include file is required because we will be using a feature that is not part of the C++11 standard. As some of the C++14 features are very useful, we provide their implementation in an internal namespace, if the compiler does not support them:
The final part of the top matter is to open a namespace into which to put everything, and then to import the dealii namespace into it.
The first significant part of this program is the class that describes the topography \(h(\hat phi,\hat \theta)\) as a function of longitude and latitude. As discussed in the introduction, we will make our life a bit easier here by not writing the class in the most general way possible but by only writing it for the particular purpose we are interested in here: interpolating data obtained from one very specific data file that contains information about a particular area of the world for which we know the extents.
The general layout of the class has been discussed already above. Following is its declaration, including three static member functions that we will need in initializing the
topography_data member variable.
Let us move to the implementation of the class. The interesting parts of the class are the constructor and the
value() function. The former initializes the Functions::InterpolatedUniformGridData member variable and we will use the constructor that requires us to pass in the end points of the 2-dimensional data set we want to interpolate (which are here given by the intervals \([-6.983333, 11.98333]\), using the trick of switching end points discussed in the introduction, and \([25, 35.983333]\), both given in degrees), the number of intervals into which the data is split (379 in latitude direction and 219 in longitude direction, for a total of \(380\times 220\) data points), and a Table object that contains the data. The data then of course has size \(380\times 220\) and we initialize it by providing an iterator to the first of the 83,600 elements of a std::vector object returned by the
get_data() function below. Note that all of the member functions we call here are static because (i) they do not access any member variables of the class, and (ii) because they are called at a time when the object is not initialized fully anyway.
The only other function of greater interest is the
get_data() function. It returns a temporary vector that contains all 83,600 data points describing the altitude and is read from the file
topography.txt.gz. Because the file is compressed by gzip, we cannot just read it through an object of type std::ifstream, but there are convenient methods in the BOOST library (see) that allows us to read from compressed files without first having to uncompress it on disk. The result is, basically, just another input stream that, for all practical purposes, looks just like the ones we always use.
When reading the data, we read the three columns but throw ignore the first two. The datum in the last column is appended to an array that we the return and that will be copied into the table from which
topography_data is initialized. Since the BOOST.iostreams library does not provide a very useful exception when the input file does not exist, is not readable, or does not contain the correct number of data lines, we catch all exceptions it may produce and create our own one. To this end, in the
catch clause, we let the program run into an
AssertThrow(false, ...) statement. Since the condition is always false, this always triggers an exception. In other words, this is equivalent to writing
throw ExcMessage("...") but it also fills certain fields in the exception object that will later be printed on the screen identifying the function, file and line where the exception happened.
create a stream where we read from gzipped data
The following class is then the main one of this program. Its structure has been described in much detail in the introduction and does not need much introduction any more.
The implementation, as well, is pretty straightforward if you have read the introduction. In particular, both of the pull back and push forward functions are just concatenations of the respective functions of the WGS 84 and topography mappings:
This function is required by the interface of the Manifold base class, and allows you to clone the AfricaGeometry class. This is where we use a feature that is only available in C++14, namely the make_unique function, that simplifies the creation of std::unique_ptr objects. Notice that, while the function returns an std::unique_ptr<Manifold<3,3> >, we internally create a unique_ptr<AfricaGeometry>. C++11 knows how to handle these cases, and is able to transform a unique pointer to a derived class to a unique pointer to its base class automatically:
The following two functions then define the forward and inverse transformations that correspond to the WGS 84 reference shape of Earth. The forward transform follows the formula shown in the introduction. The inverse transform is significantly more complicated and is, at the very least, not intuitive. It also suffers from the fact that it returns an angle that at the end of the function we need to clip back into the interval \([0,2\pi]\) if it should have escaped from there.
In contrast, the topography transformations follow exactly the description in the introduction. There is not consequently not much to add:
Having so described the properties of the geometry, not it is time to deal with the mesh used to discretize it. To this end, we create objects for the geometry and triangulation, and then proceed to create a \(1\times 2\times 1\) rectangular mesh that corresponds to the reference domain \(\hat U=[26,35]\times[-10,5]\times[-500000,0]\). We choose this number of subdivisions because it leads to cells that are roughly like cubes instead of stretched in one direction or another.
Of course, we are not actually interested in meshing the reference domain. We are interested in meshing the real domain. Consequently, we will use the GridTools::transform() function that simply moves every point of a triangulation according to a given transformation. The transformation function it wants is a function that takes as its single argument a point in the reference domain and returns the corresponding location in the domain that we want to map to. This is, of course, exactly the push forward function of the geometry we use. We wrap it by a lambda function to obtain the kind of function object required for the transformation.
The next step is to explain to the triangulation to use our geometry object whenever a new point is needed upon refining the mesh. We do this by telling the triangulation to use our geometry for everything that has manifold indicator zero, and then proceed to mark all cells and their bounding faces and edges with manifold indicator zero. This ensures that the triangulation consults our geometry object every time a new vertex is needed. Since manifold indicators are inherited from mother to children, this also happens after several recursive refinement steps.
The last step is to refine the mesh beyond its initial \(1\times 2\times 1\) coarse mesh. We could just refine globally a number of times, but since for the purpose of this tutorial program we're really only interested in what is happening close to the surface, we just refine 6 times all of the cells that have a face at a boundary with indicator 5. Looking this up in the documentation of the GridGenerator::subdivided_hyper_rectangle() function we have used above reveals that boundary indicator 5 corresponds to the top surface of the domain (and this is what the last
true argument in the call to GridGenerator::subdivided_hyper_rectangle() above meant: to "color" the boundaries by assigning each boundary a unique boundary indicator).
Having done this all, we can now output the mesh into a file of its own:
Finally, the main function, which follows the same scheme used in all tutorial programs starting with step-6. There isn't much to do here, only to call the single
run() function.
Running the program produces a mesh file
mesh.vtu that we can visualize with any of the usual visualization programs that can read the VTU file format. If one just looks at the mesh itself, it is actually very difficult to see anything that doesn't just look like a perfectly round piece of a sphere (though if one modified the program so that it does produce a sphere and looked at them at the same time, the difference between the overall sphere and WGS 84 shape is quite apparent). Apparently, Earth is actually quite a flat place. Of course we already know this from satellite pictures. However, we can tease out something more by coloring cells by their volume. This both produces slight variations in hue along the top surface and something for the visualization programs to apply their shading algorithms to (because the top surfaces of the cells are now no longer just tangential to a sphere but tilted):
Yet, at least as far as visualizations are concerned, this is still not too impressive. Rather, let us visualize things in a way so that we show the actual elevation along the top surface. In other words, we want a picture like this, with an incredible amount of detail:
A zoom-in of this picture shows the vertical displacement quite clearly (here, looking from the West-Northwest over the rift valley, the triple peaks of Mount Stanley, Mount Speke, and Mount Baker in the Rwenzori Range, Lake George and toward the great flatness of Lake Victoria):
These image were produced with three small modifications:
An additional seventh mesh refinement towards the top surface for the first of these two pictures, and a total of nine for the second. In the second image, the horizontal mesh size is approximately 1.5km, and just under 1km in vertical direction. (The picture was also created using a more resolved data set; however, it is too big to distribute as part of the tutorial.)
The addition of the following function that, given a point
x computes the elevation by converting the point to reference WGS 84 coordinates and only keeping the depth variable (the function is, consequently, a simplified version of the
AfricaGeometry::pull_back_wgs84() function):
Adding the following piece to the bottom of the
run() function:
This last piece of code first creates a \(Q_1\) finite element space on the mesh. It then (ab)uses VectorTools::interpolate_boundary_values() to evaluate the elevation function for every node at the top boundary (the one with boundary indicator 5). We here wrap the call to
get_elevation() with the ScalarFunctionFromFunctionObject class to make a regular C++ function look like an object of a class derived from the Function class that we want to use in VectorTools::interpolate_boundary_values(). Having so gotten a list of degrees of freedom located at the top boundary and corresponding elevation values, we just go down this list and set these elevations in the
elevation vector (leaving all interior degrees of freedom at their original zero value). This vector is then output using DataOut as usual and can be visualized as shown above.
If you zoomed in on the mesh shown above and looked closely enough, you would find that at hanging nodes, the two small edges connecting to the hanging nodes are not in exactly the same location as the large edge of the neighboring cell. This can be shown more clearly by using a different surface description in which we enlarge the vertical topography to enhance the effect (courtesy of Alexander Grayver):
So what is happening here? Partly, this is only a result of visualization, but there is an underlying real cause as well:
When you visualize a mesh using any of the common visualization programs, what they really show you is just a set of edges that are plotted as straight lines in three-dimensional space. This is so because almost all data file formats for visualizing data only describe hexahedral cells as a collection of eight vertices in 3d space, and do not allow to any more complicated descriptions. (This is the main reason why DataOut::build_patches() takes an argument that can be set to something larger than one.) These linear edges may be the edges of the cell you do actual computations on, or they may not, depending on what kind of mapping you use when you do your integrations using FEValues. By default, of course, FEValues uses a linear mapping (i.e., an object of class MappingQ1) and in that case a 3d cell is indeed described exclusively by its 8 vertices and the volume it fills is a trilinear interpolation between these points, resulting in linear edges. But, you could also have used tri-quadratic, tri-cubic, or even higher order mappings and in these cases the volume of each cell will be bounded by quadratic, cubic or higher order polynomial curves. Yet, you only get to see these with linear edges in the visualization program because, as mentioned, file formats do not allow to describe the real geometry of cells.
The situation is slightly more complicated if you use a higher order mapping using the MappingQ class, but not fundamentally different. Let's take a quadratic mapping for the moment (nothing fundamental changes with even higher order mappings). Then you need to imagine each edge of the cells you integrate on as a quadratic curve despite the fact that you will never actually see it plotted that way by a visualization program. But imagine it that way for a second. So which quadratic curve does MappingQ take? It is the quadratic curve that goes through the two vertices at the end of the edge as well as a point in the middle that it queries from the manifold. In the case of the long edge on the unrefined side, that's of course exactly the location of the hanging node, so the quadratic curve describing the long edge does go through the hanging node, unlike in the case of the linear mapping. But the two small edges are also quadratic curves; for example, the left small edge will go through the left vertex of the long edge and the hanging node, plus a point it queries halfway in between from the manifold. Because, as before, the point the manifold returns halfway along the left small edge is rarely exactly on the quadratic curve describing the long edge, the quadratic short edge will typically not coincide with the left half of the quadratic long edge, and the same is true for the right short edge. In other words, again, the geometries of the large cell and its smaller neighbors at hanging nodes do not touch snuggly.
This all begs two questions: first, does it matter, and second, could this be fixed. Let us discuss these in the following:
Does it matter? It is almost certainly true that this depends on the equation you are solving. For example, it is known that solving the Euler equations of gas dynamics on complex geometries requires highly accurate boundary descriptions to ensure convergence of quantities that are measure the flow close to the boundary. On the other hand, equations with elliptic components (e.g., the Laplace or Stokes equations) are typically rather forgiving of these issues: one does quadrature anyway to approximate integrals, and further approximating the geometry may not do as much harm as one could fear given that the volume of the overlaps or gaps at every hanging node is only \({\cal O}(h^d)\) even with a linear mapping and \({\cal O}(h^{d+p-1})\) for a mapping of degree \(p\). (You can see this by considering that in 2d the gap/overlap is a triangle with base \(h\) and height \({\cal O}(h)\); in 3d, it is a pyramid-like structure with base area \(h^2\) and height \({\cal O}(h)\). Similar considerations apply for higher order mappings where the height of the gaps/overlaps is \({\cal O}(h^p)\).) In other words, if you use a linear mapping with linear elements, the error in the volume you integrate over is already at the same level as the integration error using the usual Gauss quadrature. Of course, for higher order elements one would have to choose matching mapping objects.
Another point of view on why it is probably not worth worrying too much about the issue is that there is certainly no narrative in the community of numerical analysts that these issues are a major concern one needs to watch out for when using complex geometries. If it does not seem to be discussed often among practitioners, if ever at all, then it is at least not something people have identified as a common problem.
This issue is not dissimilar to having hanging nodes at curved boundaries where the geometry description of the boundary typically pulls a hanging node onto the boundary whereas the large edge remains straight, making the adjacent small and large cells not match each other. Although this behavior existed in deal.II since its beginning, 15 years before manifold descriptions became available, it did not ever come up in mailing list discussions or conversations with colleagues.
Could it be fixed? In principle, yes, but it's a complicated issue. Let's assume for the moment that we would only ever use the MappingQ1 class, i.e., linear mappings. In that case, whenever the triangulation class requires a new vertex along an edge that would become a hanging node, it would just take the mean value of the adjacent vertices in real space, i.e., without asking the manifold description. This way, the point lies on the long straight edge and the two short straight edges would match the one long edge. Only when all adjacent cells have been refined and the point is no longer a hanging node would we replace its coordinates by coordinates we get by a manifold. This may be awkward to implement, but it would certainly be possible.
The more complicated issue arises because people may want to use a higher order MappingQ object. In that case, the Triangulation class may freely choose the location of the hanging node (because the quadratic curve for the long edge can be chosen in such a way that it goes through the hanging node) but the MappingQ class, when determining the location of mid-edge points must make sure that if the edge is one half of a long edge of a neighboring coarser cell, then the midpoint cannot be obtained from the manifold but must be chosen along the long quadratic edge. For cubic (and all other odd) mappings, the matter is again a bit complicated because one typically arranges the cubic edge to go through points 1/3 and 2/3 along the edge, and thus necessarily through the hanging node, but this could probably be worked out. In any case, even then, there are two problems with this:
Consequently, at least for the moment, none of these ideas are implemented. This leads to the undesirable consequence of discontinuous geometries, but, as discussed above, the effects of this do not appear to pose problem in actual practice. | https://www.dealii.org/developer/doxygen/deal.II/step_53.html | CC-MAIN-2019-39 | refinedweb | 5,512 | 54.36 |
shutdown(2) shutdown(2)
NAME [Toc] [Back]
shutdown - shut down a socket
SYNOPSIS [Toc] [Back]
#include <sys/socket.h>
int shutdown(int s, int how);
DESCRIPTION [Toc] [Back]
The shutdown() system call is used to shut down a socket. In the case
of a full-duplex connection, shutdown() can be used to either
partially or fully shut down the socket, depending upon the value of
how.
how Interpretation
SHUT_RD or 0 Further receives are disallowed
SHUT_WR or 1 Further sends are disallowed
SHUT_RDWR or 2 Further sends and receives are disallowed
The s parameter is a socket descriptor for the socket to be shut down.
Once the socket has been shut down for receives, all further recv()
calls return an end-of-file condition. A socket that has been shut
down for sending causes further send() calls to return an [EPIPE]
error and send the SIGPIPE signal. After a socket has been fully shut
down, operations other than recv() and send() return appropriate
errors, and the only other thing that can be done to the socket is a
Multiple shutdowns on a connected socket and shutdowns on a socket
that is not connected may not return errors.
A shutdown() on a connectionless socket, such as SOCK_DGRAM, only
marks the socket as unable to do further send() or recv() calls,
depending upon the value of how. Once this type of socket has been
disabled for both sending and receiving data, it becomes fully shut
down. For SOCK_STREAM sockets, if how is 1 or 2, the connection
begins to be closed gracefully in addition to the normal actions.
However, the shutdown() call does not wait for the completion of the
graceful disconnection. The disconnection is complete when both sides
of the connection have done a shutdown() with how equal to 1 or 2.
Once the connection has been completely terminated, the socket becomes
fully shut down. The SO_LINGER option (see socket(2)) does not have
any meaning for the shutdown() call, but does for the close() call.
For more information on how the close() call interacts with sockets,
see socket(2).
If a shutdown() is performed on a SOCK_STREAM socket that has a
listen() pending on it, that socket becomes fully shut down when how =
1.
Hewlett-Packard Company - 1 - HP-UX 11i Version 2: August 2003
shutdown(2) shutdown(2)
AF_CCITT only:
The how parameter behaves differently if the socket is of the AF_CCITT
address family. If how is set to 0 the specified socket can no longer
receive data. The SVC is not cleared and remains intact. However, if
data is subsequently received on the SVC, it is cleared. The
connection is not completely down until either side executes a close()
or shutdown() with how set to 1 or 2.
If how is set to 1 or 2, the SVC can no longer send or receive data
and the SVC is cleared. The socket's resources are maintained so that
data arriving prior to the shutdown() call can still be read.
RETURN VALUE [Toc] [Back]
Upon successful completion, shutdown() returns 0; otherwise it returns
-1 and errno is set to indicate the error.
ERRORS [Toc] [Back]
shutdown() fails if any of the following conditions are encountered:
[EBADF] s is not a valid file descriptor.
[ENOPROTOOPT] The remote system or an intermediate system in
the communications path does not support a
protocol option sent by the local system. This
option may have been set using a getsockopt or
setsockopt() call, or set as a system parameter.
[ENOTSOCK] s is a valid file descriptor, but it is not a
socket.
[EINVAL] HP-UX BSD Sockets only. The specified socket is
not connected.
[ENOTCONN] _XOPEN_SOURCE_EXTENDED only. The specified
socket is not connected.
[EINVAL] _XOPEN_SOURCE_EXTENDED only. The how argument
is invalid.
FUTURE DIRECTION [Toc] [Back]
Currently, the default behavior is the HP-UX BSD Sockets; however, it
might be changed to X/Open Sockets in a future release. At that time,
any HP-UX BSD Sockets behavior that is incompatible with X/Open
Sockets might be obsoleted. Applications that conform to the X/Open
specification now will avoid migration problems (see
xopen_networking(7)).
AUTHOR [Toc] [Back]
shutdown() was developed by HP and the University of California,
Berkeley.
Hewlett-Packard Company - 2 - HP-UX 11i Version 2: August 2003
shutdown(2) shutdown(2)
SEE ALSO [Toc] [Back]
close(2), connect(2), socket(2), xopen_networking(7).
STANDARDS CONFORMANCE [Toc] [Back]
shutdown(): XPG4
Hewlett-Packard Company - 3 - HP-UX 11i Version 2: August 2003 | https://nixdoc.net/man-pages/HP-UX/man2/shutdown.2.html | CC-MAIN-2020-45 | refinedweb | 747 | 61.77 |
import "nsIDragService.idl";
Tells the Drag Service to end a drag session.
This is called when an external drag occurs
If aDoneDrag is true, the drag has finished, otherwise the drag has just left the window.
Fire a drag event at the source of the drag.
Returns the current Drag Session.
Starts a modal drag session with an array of transaferables.
Starts a modal drag session using an image.
The first four arguments are the same as invokeDragSession.
A custom image may be specified using the aImage argument. If this is supplied, the aImageX and aImageY arguments specify the offset within the image where the cursor would be positioned. That is, when the image is drawn, it is offset up and left the amount so that the cursor appears at that location within the image.
If aImage is null, aImageX and aImageY are not used and the image is instead determined from the source node aDOMNode, and the offset calculated so that the initial location for the image appears in the same screen position as where the element is located. The node must be within a document.
Currently, supported images are all DOM nodes. If this is an HTML <image> or <canvas>, the drag image is taken from the image data. If the element is in a document, it will be rendered at its displayed size, othewise, it will be rendered at its real size. For other types of elements, the element is rendered into an offscreen buffer in the same manner as it is currently displayed. The document selection is hidden while drawing.
The aDragEvent must be supplied as the current screen coordinates of the event are needed to calculate the image location.
Start a modal drag session using the selection as the drag image.
The aDragEvent must be supplied as the current screen coordinates of the event are needed to calculate the image location.
Tells the Drag Service to start a drag session.
This is called when an external drag occurs
Increase/decrease dragging suppress level by one.
If level is greater than one, dragging is disabled. | http://doxygen.db48x.net/comm-central/html/interfacensIDragService.html | CC-MAIN-2019-09 | refinedweb | 349 | 64.61 |
How NetBeans helped in 100th day of school celebration ?
My friend's daughter got a family assignment from school to commemorate 100th
day in school. If each letter in the English alphabet is assigned a weight
corresponding to it's position (e.g. "a" is 1, "b" is 2, ... "z" is 26) then she
was supposed to collect 10 words whose letters sum total to 100.
They spent last
1.5 days and found only 3 words and were discussing the problem at the lunch
table earlier today. Here is a small piece of code that I wrote to help them
out:
import java.io.BufferedReader;
import java.io.FileReader;
import java.util.Arrays;
import java.util.StringTokenizer;
public class Main {
private static final char[] WEIGHT = {
'a', 'b', 'c', 'd', 'e', 'f', 'g',
'h', 'i', 'j', 'k',
'l', 'm', 'n', 'o', 'p', 'q', 'r',
's', 't', 'u', 'v',
'w', 'x', 'y', 'z'
};
/**
* @param args the command line arguments
*/
public static void main(String[] args) throws Exception {
if (args.length == 0) {
System.out.println("At least one argument required");
return;
}
BufferedReader in = new
BufferedReader(new FileReader(args[0]));
String string = in.readLine();
while (string != null) {
StringTokenizer tokenizer = new StringTokenizer(string);
while (tokenizer.hasMoreTokens())
{
String word = tokenizer.nextToken();
if (wordStrength(word) == 100)
System.out.println("100 letters old: " + word);
}
string =
in.readLine();
}
}
static int wordStrength(String word) {
int strength = 0;
for (int i=0; i<word.length(); i++) {
int
charStrength = Arrays.binarySearch(WEIGHT, word.charAt(i));
if (charStrength
>= 0)
strength += charStrength+1;
}
return
strength;
}
}
}
This application was easily created using
NetBeans 6. And then I copy/pasted articles from my favorite news sites in a
file, passed it as command-line argument by right-clicking the project,
selecting "
Properties" and specifying the file name in "
Arguments".
Hit F6, and voila got more than 10 words :)
Technorati:
netbeans school
assignment
- Login or register to post comments
- Printer-friendly version
- arungupta's blog
- 1250 reads
by aberrant - 2008-02-05 09:18You could also take the entire aspell dictionary and search that.
Also I think you could eliminate the binary search,by casting a char to an int.
int base = (int)'a' - 1; System.out.println('a' - base); System.out.println('b' - base); System.out.println('c' - base); ...output... 1 2 3
Sure it's horribly wrong for internationalization but you are searching only English worlds. I would suspect the casting and subtraction would be faster then the binary search. It's a very cool little problem.
by kirillcool - 2008-02-04 01:04What does this have to do with NetBeans?
by kirillcool - 2008-02-04 09:47Quick code completion and suggestions can be found in any other IDE of matching strength (which would be at least Eclipse, IDEA and JDeveloper).
by arungupta - 2008-02-04 07:04You can write this code any IDE or event notepad/vi but I used NetBeans. Quick code completion and suggestions reduced the time to author this code. | https://weblogs.java.net/blog/arungupta/archive/2008/02/how_netbeans_he.html | CC-MAIN-2015-27 | refinedweb | 490 | 59.3 |
As for allowing features conditionally, there's no harm in always allowing things like _Generic or _Alignof (always reserved identifiers). The max_align_t could be defined and protected by an `#if __STDC_VERSION__ >= 201101L` as long as -std= were changed so that -std=c11 set that macro. I think there wouldn't be much harm in that even when C11 support is incomplete, as long as users know that tinycc's C11 support is incomplete. One possible issue might be that somebody might do #if __STDC_VERSION__ >= 201101L //use a not yet supported C11 feature such as _Alignas #endif so perhaps the macro controlling whether the max_align_t definition is provided had better be an internal tcc macro (e.g., __TINYC_REQUESTED_STDC_VERSION__) instead of the publicly known __STDC_VERSION__. Best regards, Petr Skocik On 1/8/19 7:51 AM, Christian Jullien wrote: > Hi all, > > > > Last commit made by Petr Skocik introduces definition of max_align_t > which is ISO/IEC 9899:2011 > > > > p. 286 > > “max_align_t > > which is an object type whose alignment is as great as is supported by > the implementation in all contexts” > > > > But, currently, tcc is supposed to implement C99 (ISO/IEC 9899:1999) > > > > printf("%d\n", __STDC_VERSION__); => 199901 > > > > Hence, it should not be defined. > > > > Now the REAL question: > > It is not clear to me which C version tcc implements. It’s an incomplete > C99 implementation, it lacks for example complex. > > > > As it pretend to be 199901, we should take care that “most” C99 are > implemented. > > New C11 features already implemented should be only available with a new > flag (like –std=c11) > > > > For example, here are the __STDC_ macros that a compiler C99 should use > or test: > > > > __STDC__ macro, 6.10.8 > > __STDC_CONSTANT_MACROS macro, 7.18.4 > > __STDC_FORMAT_MACROS macro, 7.8.1 > > __STDC_HOSTED__ macro, 6.10.8 > > __STDC_IEC_559__ macro, 6.10.8, F.1 > > __STDC_IEC_559_COMPLEX__ macro, 6.10.8, G.1 > > __STDC_ISO_10646__ macro, 6.10.8 > > __STDC_LIMIT_MACROS macro, 7.18.2, 7.18.3 > > __STDC_VERSION__ macro, 6.10.8 > > > > When we introduce a new tcc feature we should take care for which C > version it is and correctly protect its implementation when the right > –std flag is set. > > > > Wdyt? > > > > C. > > > _______________________________________________ > Tinycc-devel mailing list > address@hidden > > | http://lists.gnu.org/archive/html/tinycc-devel/2019-01/msg00030.html | CC-MAIN-2019-18 | refinedweb | 362 | 64.41 |
02 February 2011 17:14 [Source: ICIS news]
LONDON (ICIS)--Tunisian phosphate fertilizer producer Groupe Chimique Tunisien (GCT) is widely reported to have stopped all of its production and mining facilities due to strike action by employees demanding improved pay and conditions, trader sources said on Wednesday.
There was talk among market sources that GCT had declared force majeure. Although no-one from the group was available to confirm this.
GCT had been earlier reported to have encountered production and raw material supply problems due to the political turmoil in the country.
GCT had said earlier that it planned to produce 90,000 tonnes of diammonium phosphate (DAP) fertilizer in January rather than the usual 110,000 tonnes, due to planned technical repairs on a DAP line which meant that the group was temporarily producing on only one line.
These repairs had been completed and reported production issues were not due to the political unrest in the country, sources said.
Subsequently, sources added that there had been problems associated with railing phosphate rock to production sites (phosphate rock is a key raw material in DAP production).
One cargo of DAP bound for ?xml:namespace>
However, another trader said: “GCT’s output is shut down for sure – 100% certain.”
The news comes at a time when the international DAP market was already tight with most producers committed through February. GCT was the only producer with any significant tonnage to sell for February and its absence would further tighten the supply side.
GCT is a major phosphate producer of phosphate rock, phosphoric acid, DAP and triple superphosphate (TSP). Other producers include | http://www.icis.com/Articles/2011/02/02/9431875/gct-tunisia-stops-phosphate-production-due-to-strike-action.html | CC-MAIN-2013-48 | refinedweb | 269 | 50.97 |
For Day 11, the challenge is to optimize a path through a hex grid. My Python solution is below:
with open("input.txt", "r") as o: directions = o.read().split(",") DIR = { "n": (0, 1, -1), "nw": (-1, 1, 0), "sw": (-1, 0, 1), "ne": (1, 0, -1), "s": (0, -1, 1), "se": (1, -1, 0) } x = y = z = 0 max_dist = 0 def get_dist(x, y, z): return (abs(x) + abs(y) + abs(z)) / 2 for d in directions: x += DIR[d][0] y += DIR[d][1] z += DIR[d][2] max_dist = max(max_dist, get_dist(x, y, z)) print "Part 1: ", get_dist(x, y, z) print "Part 2: ", max_dist
The best place to learn about hex grids that I've seen is Red Blob Games. Once you get your head around how the grids work today's challenge isn't too difficult.
Advent of Code runs every day up to Christmas, you should join in!.
Get the latest posts delivered right to your inbox. | https://blog.jscott.me/advent-of-code-day-11/ | CC-MAIN-2018-43 | refinedweb | 163 | 84.61 |
Results 1 to 5 of 5
- Join Date
- Aug 2010
- 32
Confused on object oriented programing (C++)
class her {
public:
cout << "hi";
};
I get an error at the cout saying "This declaration has no storage class or type specifier"
Now it could be a syntax error for all I know. I knew a little bit of java and got classes working in it so I don't see what's wrong. Just for reference here is my main:
#include "stdafx.h"
#include <stdlib.h>
#include <iostream>
using namespace std;
void main()
{
her obj;
her();
system ("pause");
}
If Everything I did is a total mess, I don't expect you guys to teach me, but if you could tell me a great website, or better yet, recommend a book for C++ that would be great.
you can't put code like that into the declaration of a class, you would have to define a function and put it in the body of the function
cplusplus.com - The C++ Resources Network
- Join Date
- Apr 2007
- 119
The format of the class is wrong. I have always used C++:The Complete Reference. I am sure there are a bunch of books that are just as good, not to mention other free web sites.
- Join Date
- Apr 2009
- Location
- I can be found either 40 miles west of Chicago, in Chicago, or in a galaxy far, far away.
- 14,038
As a C++ newbie, you might want to get a copy of Deitel & Deitel "C++ How To Program" published by Prentice-Hall. It also contains an intro to object-oriented design with UML. In any case, it is a decent introductory book to the subject.Sometimes, real fast is almost as good as real time.
Just remember, Semper Gumbi - always be flexible!
- Join Date
- Aug 2010
- 32
OOP as a whole concept seems to baffle me for some reason though. It did the same thing in Java. I'll check out those sites and books though, thanks for the help guys, hope I figure this out soon.
If I don't though I do suppose I'll have an actual teacher teaching it in college but I'm no very patient :X | http://www.linuxforums.org/forum/programming-scripting/170067-confused-object-oriented-programing-c.html | CC-MAIN-2018-05 | refinedweb | 368 | 78.08 |
Type: Posts; User: Strobe
thanks everyone
This is what i got so far can someone tell me what i'm doing wrong?I'm getting two errors in the main incompatible type at infile and right under that can't find variable.
import java.util.*...
I really need help with this assignment any help would be appreciated. This assignment is gonna play a part in my final today so i would like to understand what i'm doing wrong. I would like a better...
big java
this is programming one. Can anyone lead me in the right direction i am lost don't know how to make it so that my CdList class prints out an annual report for each Certificate of deposit.
so this is what i should have:
// end of cd class
class CdList
{
// instance variable
private ArrayList<Cd>list ;
I figured out why it wasn't compiling this is what i did:
import java.util.* ; // for ArrayList and Scanner
import java.io.* ; // for File and FileNotFoundException
class Cd
{
i fixed the cd constructor by placing the identifier before each paramater. But it is giving me an error that says unexpected type double found on the arraylist part. What am i doing wrong?
ok so in the constructor i would do this?
public Cd(principal,intRate,maturity,compVal,years)
{
this.principal = principal ;
this.intRate = intRate ;
...
only thing he told us about the cd class was:
II. The CD Class
Begin by creating a class to model a CD. Each CD object "knows" its own principal, interest rate, maturity, and compounding mode...
I'm having a problems figuring out what to do next this is what the assignment calls for:
Output will be a series of 10 annual reports:
1. Each report must be clearly labeled and will include...
thanks i'll try that
This is what i got for my Cd class so far . Am i headed in the right direction?
class Cd
{
// instance variable
private int principal ;
private double intRate ;
...
Programming Assignment #8
(ArrayLists)
I. The Problem
A banking institution offers certificates of deposit (CD's) with a variety of interest rates, and maturities of 1, 3, 5, and 10...
Hello everyone i'm back again. I found another problem with my code and i need help. See my program does everything that you ask of it except that if you enter 3 digits and none match at the...
I Finally finished the program. I would like to thank all of you for your help.
I'm having a problem with my code and would really appreciate any assistance that is given. Here is an example of the problem i'm having :
Let say my secNum = 107
user enters= 701(it prints out...
thank you for your help i'm gonna take what you told me and try to fix my code.Again than you very much
public void playGame()
{
Scanner input = new Scanner(System.in);
System.out.print("Want to play? " + "Type Y for Yes or N for No and press [Enter]: ") ;
String answer =...
I got the code tags right.
i apologize for not having followed your directions but i guess i'm kinda slow . The game just keeps on looping instead of printing out my would you like to play again message when you win or get...
thank you so much for the help pete. And to everyone else Sorry about the code tags not trying to get on anyone's bad side i'll read that explanation on how to do it again do you put these on java...
Why is this method giving me a message unexpected type?It's pointing at my while statement.
public void playGame()
{
Scanner input = new Scanner(System.in);
System.out.print("Want...
How do i go about making the program so that when a user is aked if he would like to play again Yes or No, If the user types Yes the game continues if NO the game ends?
i'm stuck, these are the things i have accomplished:
generate random number (no digits repeat)
get user's guess(no digits repeat or tryagain message)
evaluate guess( i get wether... | http://forums.codeguru.com/search.php?s=215a3b3606c28a3da8b8d4e325a4424d&searchid=7000871 | CC-MAIN-2015-22 | refinedweb | 694 | 74.08 |
MapView's
getMap() method can return null. I know this is an intended behavior by Google.
Can someone provide a definitive description as to when and under which circumstances the
getMap() method returns null?
I know that if Google Services are unavailable on the given device,
getMap() will return null. This eventuality is relatively well documented. I'm more concerned with the vague other case where even when Google Services are installed on a device,
getMap() can still return null.
My assumption up to this point is that there is some initialization of the underlying maps system, during which time your code might execute and get a null map.
Am I correct in my assumption?
Is there any particular place in the Activity or Fragment lifecycle where we can definitively get a non-null
GoogleMap (if we assume Google Services IS installed)?
My goal in asking this question is to prevent a litany of
if(mapView.getMap() != null) checks littered throughout my code. In addition, this question seems to still come up on a regular basis here on StackOverflow and I'd like to see if we can flesh out the truth behind what exactly is going on with
MapView and
getMap()
Scenarios handled by Google If the google play apk is not installed you will get a null. But its somehow built in to download it from the playstore. But the playstore may not be installed so you get a null map. If the internet isn't available and the playstore is installed but google play services is not you get a null because google play services can't be installed. But coding for these senarios is done for you.
Scenarios handled by your code.
This is what you have to code for. If you deviate from the pattern outlined in the map samples you will get a null map. Every sample does it the same way. This is so if the first call in onCreate fails there is still a second chance to get the map in onResume. Your solution is to call
getMap() only in one place and save the map object that is returned. Follow the basic pattern that the map samples use. In the
onCreate and
onResume methods you call
setupmapifneeded which inturn calls
setupmap when the map object is not null.
Here's the first map sample.
/* * Copyright (C)osylvester.testapp; import com.google.android.gms.maps.GoogleMap; import com.google.android.gms.maps.SupportMapFragment; import com.google.android.gms.maps.model.LatLng; import com.google.android.gms.maps.model.MarkerOptions; import android.os.Bundle; import android.support.v4.app.FragmentActivity; /** * This shows how to create a simple activity with a map and a marker on the map. * <p> * Notice how we deal with the possibility that the Google Play services APK is not * installed/enabled/updated on a user's device. */ public class BasicMapActivity extends FragmentActivity { /** * Note that this may be null if the Google Play services APK is not available. */ private GoogleMap mMap; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.basic_demo); setUpMapIfNeeded(); } @Override protected void onResume() { super.onResume(); setUpMapIfNeeded(); } /** * FragmentActivity after following the prompt and correctly * installing/updating/enabling the Google Play services. Since the FragmentActivity may not have been * completely destroyed during this process (it is likely that it would only be stopped or * paused), {@link #onCreate(Bundle)} may not be called again so we should call this method in * {@link #onResume()} to guarantee that it will be called. */(); } } } /** * This is where we can add markers or lines, add listeners or move the camera. In this case, we * just add a marker near Africa. * <p> * This should only be called once and when we are sure that {@link #mMap} is not null. */ private void setUpMap() { mMap.addMarker(new MarkerOptions().position(new LatLng(0, 0)).title("Marker")); } }
Google has a more convenient way to get the map using the following method, because it might depend from a device to device to get the map ready! Use the following method to get the map when it is ready.
myMapFragment.getMapAsync(new OnMapReadyCallback) { @Override public void onMapReady(GoogleMap googleMap) { myMap = googleMap; } });
I have an Android Tab3 Running Android 4.2.2 All I had to do is update google maps and it did the trick. | http://m.dlxedu.com/m/askdetail/3/6b9957a2355cec6456fdeb9bf70fc04f.html | CC-MAIN-2019-18 | refinedweb | 716 | 65.83 |
:
- HsFFI.h
- The external FFI api
- RtsAPI.h
- The top-level interface to the RTS (rts_evalIO(), etc.)
- SchedAPI.h
- External API to the RTS scheduler
- RtsFlags.h
- External API to the RTS runtime flags
- Linker.h
- External API to the linker
Used when compiling via C
These header files are #included into the .hc file generated by GHC when it compiles Haskell code to C.
These days the amount of stuff included this way is kept to a minimum, because we don't want to pollute the C namespace with too much extraneous goop.
- Stg.h
- The top of the hierarchy is Stg.h, which includes everything required by .hc code. The following files are #included by Stg.h:
- ghcconfig.h
- Configuration info derived by the configure script.
- RtsConfig.h
- Settings for Rts configurables (eg. eager vs. lazy BH)
- MachDeps.h
- Sizes of various basic types.
- StgTypes.h
- Basic types specific to the virtual machine (eg. StgWord).
- TailCalls.h
- Tail calls in .hc code.
- StgDLL.h
- Stuff related to Windows DLLs.
- MachRegs.h
- Global register assignments for this processor.
- Regs.h
- "registers" in the virtual machine.
- StgProf.h
- Profiling gubbins.
- StgMiscClosures.h
- Declarations for closures & info tables built-in to the RTS
- RtsExternal.h
- Declarations for RTS things referred to by .hc code. (NOTE: also includes RtsAPI.h and HsFFI.h.
Included into the RTS source code itself
Some of the header files here define important aspects of the implementation of the runtime, such as Closures.h which defines structures representing the layout of closures.
All such header files lie below Rts.h in the inclusion hierarchy, in general all RTS sources #include Rts.h. Pretty much all the header files in this directory fall into this category.
- Rts.h
-
- RtsTypes.h
- Types used in the RTS
- Constants.h
- Build-time constants
- StgLdvProf.h
-
- StgFun.h
-
- Closures.h
- The layout of closures.
- Liveness.h
- macros for constructing RET_DYN liveness masks
- ClosureMacros.h
-
- ClosureTypes.h
-
- InfoTables.h
- The layout of info tables.
- TSO.h
- The structure of Thread State Objects.
- Updates.h
- Macros for performing updates.
- GranSim.h
-
- Parallel.h
-
- SMP.h
- Macros for multiprocessor support, eg. cas().
- Block.h
- The block allocator, block descriptors, Bdescr().
- StgTicky.h
- Ticky-ticky profiling.
- Stable.h
- Stable pointers, stable names.
- Hooks.h
- Hooks for changing RTS behaviour.
- Signals.h
- The API for using Signals from Haskell.
- DNInvoke.h
- .NET stuff (bitrotted).
Included into C-- code
- Cmm.h
- included into .cmm source only [
- DerivedConstants.h]
- generated by mkDerivedConstants.c from other .h files.
(Constants.h) (ClosureTypes.h) (StgFun.h) (MachRegs.h) (Liveness.h) (Block.h)
Included into various non-C source code
Some of these header files are #included into Haskell code or C-- (.cmm) code, so that we can have one place for defining constants and configuration settings. Files in this category therefore must contain #defines only, no C code or declarations.
The following headers are in this category:
- config.h
-
- RtsConfig.h
-
- Constants.h
-
- DerivedConstants.h
-
- ClosureTypes.h
-
- StgFun.h
-
- MachRegs.h
-
- Liveness.h
-
- StgLdvProf.h
-
Miscellaneous
- Bytecodes.h
- Bytecode definitions for the interpreter
- ieee-flpt.h
- ToDo: needed? | https://ghc.haskell.org/trac/ghc/wiki/Commentary/SourceTree/Includes?version=1 | CC-MAIN-2016-18 | refinedweb | 516 | 54.79 |
This tutorial gives you a whirlwind tour of Visual Web JSF application development in NetBeans IDE 6.0 or 6.1. The tutorial shows you how to use Visual Web JSF Application functionality and JavaServer Faces 1.2 (Woodstock) components to perform the typical phases of web application development.
The tutorial is designed so that you do not need to go through it in any particular order. You might want to skim over it quickly and then return to each section as time allows. If you prefer a step by step tutorial, you might want to first try Developing a JSF Web Application. project is the equivalent of your working environment for a web application. When you create a Visual Web JSF Application project and you have specified GlassFish V2 or later as an application server in the NetBeans IDE, the IDE can create a web application based on Java EE 5 that uses JavaServer Faces 1.2 components. By default, the web application is created in a directory structure that conforms to the Java BluePrints project conventions for web applications.
Try It
Start the IDE by using the appropriate step from the following list:
/Applications/NetBeans/
Create a Visual Web JSF Application project:
Note for NetBeans IDE 6.1 users: Creating a project in NetBeans 6.1 includes new options which can be left at the default. For example, the Use Dedicated Folder for Storing Libraries checkbox may be left unselected.
Choose a server and Java EE version.
Explore the Projects window. As shown in the following figure, the Projects window groups items by category. Expand each of the nodes to see what type goes in each category..
.jsp
.java
For More Information Projects window, right-click the Web Pages node and choose New > Visual Web JSF Page, as shown in the following figure.
Accept the default name of Page2 and click Finish. The IDE opens Page2 in the Visual Designer, which is in the editing area, as shown in the following figure..
Click the JSP button in the editing toolbar to see the JSP code for the page, as shown in the following figure. Notice how the JSP page uses JSP document syntax. Woodstock Basic, Woodstock Layout, and Woodstock.
Open Page2 that you created by following the Try It suggestions in the Creating Web Pages section, or create it if necessary.
Drag various components from the Basic section and the Layout section of the Palette window and play around with their properties. For example, try the following steps:
Click Me!
text
primary.
Name:
for
id
labelLevel
label
Color
Blue
White
Green
Use similar steps to create a Radio Button Group component with the choices Blue, White, and Red, but do not close the Options Customizer quite yet..
When you are ready to test a project, press F6 or choose Run > Run Main Project from the main menu. The IDE takes the following actions:
Compiles any files that need to be compiled.
Deploys the application to the application server.
Opens a browser and sends the URL for the deployed application to the browser which, in turn, displays the start page.
Note: If you added components to a page other than the start page, at this point in the tutorial you will not see them in the web browser. See the Try It section below for a way to set up navigation from the start page to another page in your application.
If you have made a lot of changes or deleted several items, or if you are seeing some unexpected behavior, you can choose Build > Clean and Build Main Project from the main menu. The IDE cleans out the project's build directory and dist directory, undeploys the web application, and then builds and deploys the application.
build
dist
Page
url
/faces/page-name.jsp
Return to the IDE, and, in the Services window, expand Servers and expand the server's node, and then expand Applications > Web Applications and note that there is a node for your project, as shown in the following figure.
When a user types a URL, clicks a link, or clicks a button, the browser sends a request to the server. The server maps the request to a JSP page and uses that JSP page and its associated page bean to render a response.
You can specify page navigation in one of two ways:
/faces/
To access the Page Flow editor, right-click the page background in the Visual Designer and choose Page Navigation.
The Page Flow editor shows page icons for all the pages in the project. When you click the + element of a page icon in the Page Flow editor, the icon expands and shows all its action components, components that have an action property, such as a Button, a Hyperlink, or a Tab. Next to each component is a connector port. In the image below the hyperlink's connector port resembles a chain and the button's shows an arrow. You drag from the connector port to a page icon to create the mapping between that action's request and the page to be rendered as a response to the request. When you release the mouse, the IDE adds a visual representation of that connection, as shown in the connection labeled nextPage in the following figure.
Note: When a page is submitted, the web application performs conversions and validations before it executes action methods. If a conversion or validation fails, the action methods do not get called. You should put Message Group components on a page during development so that you can catch any unexpected conversion or validation error that might prevent an action method from being invoked.
Go
Double-click the Button component to access the button's action method.
nextPage
go
In Page2, double-click the Button component to access the button's action method.
The IDE's Java editor is packed full of features to facilitate the programming process, many more than can be discussed in this introductory tutorial. If you click inside a Java editor window and press F1, you can get help on most of the features of this editor.
The following descriptions cover a few of the more useful editing features.
Code Completion. Code completion enables you to type a few characters and then choose from a list of possible classes, methods, variables, and so on to automatically complete the expression. To display the code completion box, press Ctrl-Space. The code completion box also appears when you pause after typing a period that follows a package name, a variable, or a method call, as shown in the following figure.
Error detection. Red error boxes appear in the left margin of all statements that will not compile. Hover the mouse over the box to see the description of the error, as shown in the following figure. The IDE also displays an error strip on the right margin. This strip represents the whole file, not just the lines of code that are visible. Red lines in the error strip identify errors in the code. Double-click a red line to jump to the erroneous statement. When you compile files, all compilation errors appear in the Output window. Click an error message to display the erroneous code in the Java Editor.
Java Editor Keyboard Shortcuts. You can invoke many common editing tasks with a simple key combination as shown in the following examples. To learn more about the shortcuts, choose Help > Help Contents from the main menu to open the Help viewer, and then in the Contents pane choose IDE Basics > Keyboard Shortcuts > Editor Shortcuts.
Code Templates . Code Templates are short groups of characters that expand into a full word or phrase when you press the spacebar, as shown in the following examples. To see the full list of code templates, choose Tools > Options on a Microsoft Windows system or NetBeans > Preferences on a Macintosh system, and then choose Basic Options > Editor > Code Templates and click the ellipsis button for the Code Templates property. Some examples:
for (Iterator it = collection.iterator(); it.hasNext();)
{Object elem = (Object) it.next();}
forc
for (int i = 0; i < arr.length; i++) {}
fori
try {|} catch (Exception ex)
{log("Error Description", ex); } finally {}
trycatch
Code Clips. When you have the Java editor open, the Palette window provides many useful code clips that you can drag and drop onto your source file. The code clips do not appear for managed bean source files, such as the source file for an application bean or a request bean.
Note: The following exercises have you type code in the destroy method. The code that you type is meant to illustrate the editing features. You would not normally put code like this in this method. After you complete the steps, you should remove the code.
destroy
destroy()
getSessionBean1().
d
this.getH
getHyperlink1()
set
te
setText(Object text)
setText()
"hello"
;
serr
System.err.println("")
getSes
The IDE provides validator and converter objects to facilitate input checking and formatting. These objects can be found in their respective sections in the Palette.
You bind a validator to an input component, such as a Text Field component, by dropping the validator onto the input component. For example, after you add a Text Field component to a page in the Visual Designer, you can drag a Length Validator from the Validators section in the Palette and drop it on the Text Field.
Alternatively, you can drop the validator onto the page and set the input component's validator property to that validator object. For example, you can drop a Long Range Validator on a blank spot on the page, which adds longRangeValidator1 to the Navigator window. You can then select an input component in the Visual Designer, such as the Text Field component, and choose longRangeValidator1 from its validatorExpression property's drop-down list. You can use the same validator for more than one component.
validator
validatorExpression
The mechanisms are similar for converters. You can also associate converters with output components, such as the Static Text component. Note that when you bind a component to a data provider field, the conversions are done automatically. You learn about binding to data providers in the Connecting to Databases section.
You use the validator's Properties window to set the validation rules, such as the minimum and maximum value or the minimum and maximum length. Similarly, you use the converter's Properties window to set the conversion rules, such as the pattern that the value should match or the method to call to do the validation. The Number converter has a special wizard that appears when you first drop the Number Converter onto the page or onto a visual component.
The Basic section of the Palette provides the Message component and the Message Group component for automatically displaying conversion errors, validation errors, and required-field messages. The Message Group component displays global error messages, runtime errors and, optionally, all the component error messages. A Message component displays only the messages for the component to which it is bound. You bind a Message component to another component by setting the Message component's for property or by pressing Ctrl-Shift on the Message component and dragging the mouse to the component to which you want to bind the Message component.
You can programmatically send custom error messages to the Message Group component using the error, warn, fatal, and info methods in any Page Bean. To learn more about these methods, choose Tools > Javadoc Index Search, type FacesBean in the text field for the drop-down list, and click Find.
error
warn
fatal
info
FacesBean
required
Price:
In the Palette, expand the Validators section. Drag a Double Range Validator and drop it on the Text Field component. In the Navigator window, select the newly created doubleRangeValidator1 node. In the Properties window for the validator, set the maximum to 10.0 and set the minimum to 1.0, as shown in the following figure.
10.0
1.0
In the Palette, expand the Converters section. Drag a Number Converter and drop it on the Text Field component. A Number Format dialog box appears, as shown in the following figure. Select currency from the Type drop-down list, select English (United States) from the Locale drop-down list, and click OK.
Add a Message component to the page. Press Ctrl-Shift on the component and drag to the Text Field component.
Make the page the start page and run the application. Try clicking
the button with no price entered, with 1.5 entered,
with a non-numeric value, and with a price greater than $10.00.
Finally, type $1.50 in the text field and click the button.
1.5
$1.50
showGlobalOnly
You use the Application Bean, the Session Bean, and the Request Bean to store information for use by other pages.
If you need the information only for use by the next page, use the Request Bean.
Any value that you store in the Request Bean disappears as soon as the request ends. A request is a single transmission of an HTTP request from the client to the server plus the corresponding response, which can be another page. In most cases, the request begins with the clicking of a button or a link, and ends with the response of an HTML page to be displayed.
Note: The Request Bean gets instantiated only if the page that initiates the request stores values in Request Bean properties, such as when an input component is bound to a Request Bean property as described below.
<redirect>
<navigation-case>
To add a property to the Session Bean:
Double-click the SessionBean1 node in the Navigator window.
answer
Right-click in the editor and choose Refactor > Encapsulate Fields. In the resulting dialog, create the getter method if the property is Read Only and both the getter and setter methods if the property is Read/Write.
Use similar steps to add a property to the Request Bean or the Application Bean. For more information see the FAQ How do I add properties to managed beans in NetBeans IDE?
Note: You can also add properties to a page bean (the backing bean that the IDE creates for each page). To add a property to a page bean, open the page's java code and add the propery declaration to the constructor public class Page1 extends AbstractPageBean, and encapsulate the fields as above. Page bean property values last only as long as the page bean is instantiated. For example, when the user clicks a Button component that rerenders the page (that is, the action method returns null), a new instance of that page bean is created, and the page bean's property values are reinitialized. If you want to pass a value to the postback, you can use Hidden Field components.
To associate a component with a bean's property, right-click the component and choose Bind to Data. In the Bind to Data dialog box, select the Bind to Object tab and choose the bean's property, as shown in the following figure.
Note: For most components, the pop-up menu provides two binding actions - Property Bindings and Bind to Data. The Property Bindings dialog box enables you to bind any of the component's properties to a managed bean property or a data provider field. The Bind to Data dialog box is a shortcut for binding the component's value-holding property to a managed bean property or a data provider field. Use the Bind to Data Provider tab to bind to any data provider that you have added to the page or a managed bean. Use the Bind to an Object tab to bind to a page property or a managed bean property.
Add a property to RequestBean1.java: Name the property parm, make it a String and allow users read/write access.
parm
String
The Services window includes a Databases node, which shows all the databases that are registered with the IDE, as shown in the following figure. NetBeans IDE provides a sample TRAVEL database which you use in the remainder of this tutorial.
Before you can access a database from a project, you must first connect the IDE to the database. You must do this every time you start the IDE and open a project that is connected to the database.
If a database's badge appears broken and you cannot expand the database's node, the IDE is not connected to the database. To connect to the TRAVEL database, right-click the database's node in the Services window and choose Connect from the pop-up menu. If the Connect dialog box appears, enter travel for the Password and select Remember Password During This Session.
travel
When you open an existing project, the Visual Designer might show an error screen. Typically, this is because the Visual Designer needs to get information from the database, but the IDE is not connected to the database. Try connecting to the database server and clicking the Continue button in the error screen to resolve the problem.
You can connect a page to a database table by dragging the table from the data sources section and either dropping it on a component or dropping it on the page. When you do this, the IDE adds a data provider to the page and a rowset to the SessionBean1 class, as shown in the following figure.
The rowset object makes the connection to the database, executes the queries, and manages the result set. The data provider object provides a common interface for accessing many types of composite data, from database tables, to ArrayList objects, to Enterprise JavaBeans objects. Typically, the only time that you work with the rowset object is when you need to set query parameters. In most cases, you use the data provider object to access and manipulate the data.
ArrayList
Once you have added a data provider to a project, you can bind a component to the data provider by right-clicking the component and choosing Bind to Data. In the Bind to Data dialog box, click the Bind to Data Provider tab to bring it to the front. The Choose a Data Provider drop-down list shows all the project's data providers from which you can select the data provider to bind to the component. After you select the data provider, choose the appropriate data column to be bound to the component. For some components, such as the Drop Down List component, you must choose both a Value field and a Display field.
To define the SQL query to use to retrieve the data, you use the Query Editor, as shown in the following figure. You access this editor through a rowset object.
Drag the TRIPTYPE node onto the page.
(Optional) Look in the _init method in the page's Java source code to see the code for associating the data provider with the rowset. This method is folded by default. To unfold the code, click the code fold box that appears next to the left margin.
_init
The IDE has a built-in debugger to help you troubleshoot your programs, as shown in the following figure. You can use it to set breaks and watches, to step through code, and to run until it reaches the code statement that the cursor is on.
You set a breakpoint by clicking in the left margin of the Java Editor. You set a watch by right-clicking a variable or expression choosing New Watch. To run the debugger, choose either Run > Debug Main Project or Run > Run to Cursor from the main menu.
Tip: Here are some other features that you can use to diagnose and resolve problems:
log
Hello
helloText
Add a Button component. Double-click the Button component to access its action method (button1_action) and replace the method's body with the following code.
button1_action
String oldString = (String) this.helloText.getText();
this.helloText.setText("Good Bye");
String newString = (String) this.helloText.getText();
return null;
Right-click oldString, choose New Watch, and click OK. Do the same for newString.
oldString
newString
Click in the left margin to set a breakpoint for the first statement in the method's body.
Bookmark this page | http://www.netbeans.org/kb/60/web/intro.html | crawl-001 | refinedweb | 3,377 | 61.97 |
Alibabacloud.com offers a wide variety of articles about facebook php file, easily find your facebook php file information here online.
Objective The United States has been leading the technology trend, take the open this matter, also from Google Play to Facebook to Twitter, three companies to play the open API. If not, it is unlikely that Facebook and Twitter will emerge in such a
Facebook stores 6.5 billion photos of the storage frame <?xml:namespace prefix = o Facebook has never been used, but it is still interested in the large capacity of unstructured data storage s
Facebook stores 6.5 billion photos of the storage frame <?xml:namespace prefix = o Facebook has never been used, but it is still interested in the large capacity of unstructured data storage s
Use Java and PHP in parallel Introduction: Part 2nd of this tutorial series covers the details of the Facebook application development that you started in part 1th, building a Facebook interface with existing stock brokers to enable them to manage o
There's a move in the company today, and one of the activities is to ask visitors to click on Facebook's Sanuki and Sanuki giveaway to send the gold. Facebook has been wall by everyone, and Baidu has discovered that because of the wall, the reason
Label:A PHP extension for Facebook ' s ROCKSDB commits 2 Branches 0 Releases 2 Contributors C + + 90.5% C 8.9% other 0.6% C + +c OtherBranch: Master rocksdb-php/ Merge Pull request #1 from Miclen/
Why Facebook's hiphop to convert PHP to C + + instead of converting PHP into a compiled language ... Is it faster to execute the compiled file directly? Reply content:The first thing to do is to look at the whole history: Facebook has launched the
Just like its login address, like this . Usually most of the PHP site does not do some routing distribution, the actual address hidden it? Why doesn't Facebook do this, does it really call this file directly login. | https://topic.alibabacloud.com/zqpop/facebook-php-file_35241.html | CC-MAIN-2019-30 | refinedweb | 337 | 58.11 |
Click on an element in GridView and invoke a function
Hi everyone,
I have a class (PLModel) subclassing QAbstractItemModel and passed to a QML GridView through the context. The display works fine. The problem is that i want to be able to click on one of those item and invoke a function that acts differently according to the element that has been clicked.
Here is the code i've come up with so far :
plmodel.hpp (simplified)
class PLModel : public QAbstractItemModel { public : // Constructor PLModel() // The functions to subclass QAbstractItemModel // index, parent, rowCount, columnCount, data, hasChildren, setData, flags, roleNames // The method I want to invoke Q_INVOKABLE virtual void activateItem( const QModelIndex &index ) Q_DECL_OVERRIDE; // Other irrelevant stuff ... };
plmodel.cpp (simplified)
PLModel::PLModel() { } // The imlementation of the functions to subclass QAbstractItemModel // The method I want to invoke void PLModel::activateItem( const QModelIndex &index ) { // For debug log_debug (index.row()) log_debug (index.column()) // Do some other stuff according to the selected item // item = getItem ( index ) ... }
ui.qml
import QtQuick 2.0 Item { width: 1000 height: 1000 GridView { id: gridView anchors.fill: parent cellWidth: 150 cellHeight: 150 model: m // This variable comes from context (= instance of PLModel) delegate: Item { x: 5 height: 50 Image { anchors.horizontalCenter: parent.horizontalCenter id: image width: 100 height: 100 source: model.image MouseArea { anchors.fill: image onClicked: m.displayInfo(index) // Where i call the function } } } } }
Then when i click on an element, the function is called correctly but the 'index' is not correct : index.row = -1 & index.column = -1 (not matter which element i pick). Thus i can't decide what to do because i don't know which element was clicked. I don't understand why i get this index. Am i doing something wrong ? Is there another way to do what i want to do ?
Thx,
MoaMoaK
- sierdzio Moderators
Please do not double-post. I'm closing this one. | https://forum.qt.io/topic/82361/click-on-an-element-in-gridview-and-invoke-a-function | CC-MAIN-2018-51 | refinedweb | 310 | 50.33 |
Your Account
by Simon St. Laurent
Related link:
Every now and then I see a proposal go by for something I've wanted for years. Today, it's the Really Simple Database Protocol.
I am not an enterprise developer. I rarely give a damn about scalability beyond five simultaneous users. I've argued in the past that developers need to look beyond scalability, and I've argued repeatedly that simpler solutions make a lot more sense for a larger group of people than do highly sophisticated but deeply complicated (think Web Services, EJB, etc.) systems that try to solve every problem.
The Really Simple Database Protocol, from my perspective, is close to perfect. It runs over a verbose but trivial protocol, relying on well-known tools (XML-RPC and SQL) to do simple tasks. The relational database on the other end lets me work with large volumes of highly structured data, and it doesn't matter (outside of SQL details and features) what database is on the other end of the connection. Nor does the database need to know much about the client.
Yes, there are performance issues, especially if you hit such a server with a few thousand SQL queries simultaneously generating large volumes of returned data. Using HTTPS increases the processing cost, while using HTTP leaves authentication data unguarded. Binary files transferred via XML-RPC become extremely verbose.
Sure, hitting your head against this wall will hurt. If those problems affect you, don't use this. For those of us who just want to connect database A to client B with a minimum of fuss, this is just the duct tape I've been looking for.
Is duct-tape okay, or do we need to solve every problem with titanium alloys adhered with high-strength epoxy adhesives applied using precision robotics?
Yes, any client language/environment that wants to talk to a database via ODBC needs to implement an ODBC-speaking extension, but so would any database that wants to listen for RSDP requests, so that seems like a wash.
I've never liked ODBC, can't say I ever will, and think it tries to solve too many more problems than RSDP, at least for what I need.
The only major plus I can think of for ODBC is that it's widely deployed. That usually wins, of course!
RDSP is just a napkin-fantasy.
It's good (if surprising) to know that there are people out there who actually _like_ (well enough to defend, anyway) ODBC.
With a consistent XML-RPC interface, none of this middleware is necessary. You can use XML-RPC to submit the query across the wire and get a recordset back. In Python, XML-RPC is in the core library, so I can do this in three lines of code (sans error trapping, etc).
from xmlrpclib import Server
db = Server("")
xmlrs = db.rsdp("books","guest","password","sql","SELECT * FROM 'books' WHERE author = 'Brian McConnell' ORDER BY pubdate;',false,"xml")
from xmlrpclib import Server
db = Server("")
xmlrs = db.rsdp("books","guest","password","sql","SELECT * FROM 'books' WHERE author = 'Brian McConnell' ORDER BY pubdate;',false,"xml")
The point here is that with an interface like RSDP you can write lightweight programs that do not require the target machine to be explicitly configured to talk to a database server. The problem with current DB tools is that the machine running DB-aware scripts needs to be configured to talk to the chosen back-end. With something like RSDP, it will be possible to write DB oriented programs without knowing nearly as much about the machines they'll run on.
At present, every time I get involved in a database project, I spend the majority of my time troubleshooting the database environment, and a minority building and maintaining my application. This ratio should be reversed, with database connectivity involving little more than looking up the URL for the database service, invoking an RPC call and capturing a result.
I don't have experience with ODBC, but JDBC, which I believe is similar. Again, idea of JDBC is simple. Devil's in the details...
Obviously ODBC and JDBC win hands down for any enterprise-level applications due to scalability alone, but they're not a good choice over the Web due to the many calls required by the low level of their APIs. RSDP allows you to make a single call and get the results back in a single document, which is sufficient for a lot of applications.
One solution to implementation problems is for someone to simply write an RSDP implementation over ODBC or JDBC. It would take far longer to write the configuration code than the database access code.
The problem then is who would actually be willing to deploy it. How many useful databases are out there whose owners are willing to open them up to public perusal?
© 2014, O’Reilly Media, Inc.
(707) 827-7019
(800) 889-8969
All trademarks and registered trademarks appearing on oreilly.com are the property of their respective owners. | http://archive.oreilly.com/pub/post/simple_enough_to_be_useful.html | CC-MAIN-2014-41 | refinedweb | 841 | 62.48 |
See the true impact of code changes on the behavior and performance of your software.
Fixing silly mistakes shouldn't need a round-trip with your QA team.
It takes 23 days for software engineers to gain confidence that a given code change works as they expect.
Touca reduces this to minutes.
."
Use our open-source SDKs to capture values of variables and runtime of functions, for any number of test cases, from anywhere within your code.
import touca @touca.Workflow def is_prime(testcase: str): touca.check("output", is_prime(int(testcase))) if __name__ == "__main__": touca.run()
We remotely compare your description against a previous trusted version of your software and report differences in near real-time.
Hi Bob,
A new version v2.0 was submitted for suite Tax Calculator.
We compared this version against v1.0 (baseline). We found no differences between common test cases. There were no new or missing test cases.
Receive notifications when differences are found. Work together to resolve or justify them. Maintain a shared understanding of how your software works and is supposed to work.
Hi Bob,
Alice Anderson promoted v5.0 of suite Tax Calculator as the new baseline. All subsequent versions will now be compared againstv5.0. They provided the following reason for this change.
Changed the logic to include child tax credit. Differences for test case bob are expected.
Automate the execution of your tests, locally or as part of your build pipeline, or on a dedicated test server; however you like, whenever you like. We give you real-time feedback, when you need it.
Touca Test Framework
Suite: sample/1.0
1.PASSJoseph Buquet(222 ms)
2.PASSChristine Daaé(235 ms)
3.PASSRaoul de Chagny(253 ms)
4.SKIPMarius Pontmercy
5.PASSJean Valjean(249 ms)
Tests:5 passed, 1 skipped, 5 total
Time:1.01 s
✨ Ran all test suites. | https://touca.io/ | CC-MAIN-2022-21 | refinedweb | 309 | 62.64 |
Hi,
can some one help me , to get the table value in tool tip at mouse over and attached image for better understanding
Hi,
can some one help me , to get the table value in tool tip at mouse over and attached image for better understanding
you’ll probably have to change the column to be a view with a label and put your tooltip on the label
@victordcq Thanks for the reply, can u pls elaborate…
presently, am able to get the value on tool tip based on the selection(Table Events-on click-Pushing Table Data Selection).
Is your question how to get the value of the cell you are hovering over, or how to get the tool tip to show at the location where you are hovering?
Create a view with a label in it. (ex labelWithTooltip) (best probably a flexcontainer)
Give it a view param named value
Bind the labels text to the param.value
Bind the labels tooltip text to the param.value, and enable tooltip
In your table, add columns to the column param, be sure to match field with the data’s name
set columns.viewPath to your label view path (labelWithTooltip)
set columns.render to view
done
yes, am looking get the value of the cell, when we hover mouse
Why? Is it not already visible in the cell or are you displaying something else?
Hey thanks,
Its working for me for string values, am not able to get the number values in the tool tip, is there any other changes need to be done for numbers (Table Population columns)…
Hey, posted image with test data.
Actually condition, we are opening the report based on the SN selection on table,
sometimes SN will not fit in the column So, will provide same on tooltip.
it convert to string then with an expression toString - Ignition User Manual 8.1 - Ignition Documentation
I looked at this a little bit, but I didn’t come up with as clean a solution as @victordcq for this application, but nevertheless, I figured I would go ahead and post what I had developed in case the direction could be of use to somebody.
def runAction(self, event): #============================================== # self.props.columns[0].strictWidth = True # self.props.columns[1].strictWidth = True # self.props.columns[2].strictWidth = False #============================================== self.props.rows.height = 30 mousePositionX = event.pageX-self.position.x mousePositionY = event.pageY-self.position.y row = (mousePositionY/self.props.rows.height)-2 if mousePositionX < self.props.columns[0].width: self.meta.tooltip.text = str(self.props.data[row].city) elif mousePositionX < (self.props.columns[0].width + self.props.columns[1].width): self.meta.tooltip.text = str(self.props.data[row].country) else: self.meta.tooltip.text = str(self.props.data[row].population)
The preceeding code running on the onMouseMove event script produces the following result:
It uses the mouse position relative to the component’s placement, cell height, and column width to determine what cell the mouse is hovering over
@justinedwards.jle
i doubt that will work with scrolling:/
Agreed
Thanks for ur support, i will check the same.
Meanwhile, kindly share some resources to explore cust properties like event.pageY-self.position.y…
Just throw a label somewhere on the page and use something like this in the event you’re wanting to use. It will reveal a lot of what is available:
self.getSibling("Label").props.text = str(event)
The preceding code on the table’s onMouseMove event results in this being printed in the label:
From there, if you see something that looks useful, just look it up directly in the online ignition resources. The information available is extensive. | https://forum.inductiveautomation.com/t/ignition-perspective-table-mouse-over-value/63759 | CC-MAIN-2022-40 | refinedweb | 611 | 53.81 |
In this section, we look at a few of Python's many standard utility modules to solve common problems.
File System -- os, os.path, shutil
The os and os.path modules include many functions to interact with the file system. The shutil module can copy files.
- os — Python 2.7 documentation
-)
import os## Example pulls filenames from a dir, prints their relative and absolute pathsdef printdir(dir):filenames = os.listdir(dir)for filename in filenames:print filename ## foo.txtprint -- subprocess
The subprocess module is a simple way to run an external command and capture its output.
- subprocess module docs
- status = subprocess.call(cmd, shell=True) -- runs the command, waits for it to exit, and returns its status int. Any output from the command gets to the printed as usual. The status will be non-zero if the command failed.
- status = subprocess.call(cmd, shell=True, stdout=file1, stderr=file2) -- same as above, but capture the commands output and error into files file1 and file2 respectively.
import sysimport subprocess## Given a dir path, run an external 'ls -l' on it --## shows how to call an external programdef listdir(dir):cmd = 'ls -l ' + dirprint "Command to run:", cmd ## good to debug cmd before actually running it## Run the command while capturing output and errorf1 = open('tmp', 'w')f2 = open('tmp2', 'w')status = subprocess.call(cmd, shell=True, stdout=f1, stderr=f2)f1.close()f2.close()f1 = open('tmp', 'r')f2 = open('tmp2', 'r')## print output and errorif status: ## Error case, print error and exitprint "There was an error: "print f2.read()sys.exit(status)print f1.read() ## print the captured list of Built-in Exceptions. — Python 2.7 documentation
-.
import urllib## Given a url, try to retrieve it. If it's text/html,## print its base url and its text.def wget(url):ufile = urllib.urlopen(url) ## get file-like object for urlinfo = ufile.info() ## meta-info about the url contentif info.gettype() == 'text/html':print 'base url:' + ufile.geturl()text = ufile.read() ## read all its textprint text
The above code works fine, but does not include error handling if a url does not work for some reason. Here's a version of the function which adds try-except logic to print an error message if the url operation fails.
import urllib## Version that uses try/except to print an error message if the## urlopen() fails.def wget2(url):try:ufile = urllib.urlopen(url)if ufile.info().gettype() == 'text/html':print ufile.read()except IOError:print 'problem reading url:', url
Content was originally based on, but has been modified since. Licensed under CC BY 3.0. Code samples licensed under the Apache 2.0 License. | https://www.commonlounge.com/discussion/59bfdf9345fe449191edb161d57c7c50 | CC-MAIN-2019-26 | refinedweb | 443 | 60.01 |
Important: Please read the Qt Code of Conduct -
HTTP request
Hello, I try to create HTTP request in Qt, this is my include section:
#include "QHash" #include "QFile" #include "QCryptographicHash" #include "QtNetwork/QNetworkRequest" #include "QtNetwork/QNetworkAccessManager" #include "QUrl" #include "QUrlQuery" #include "QDebug"
This is code:
QUrl url(""); QUrlQuery query; query.addQueryItem("username", "test"); query.addQueryItem("password", "test"); url.setQuery(query.query()); QNetworkRequest request(url); request.setRawHeader("X-Parse-Application-Id", "myappid"); request.setRawHeader("X-Parse-REST-API-Key", "myapikey"); QNetworkAccessManager *manager = new QNetworkAccessManager(this); manager->get(request);
and there are errors:
What is wrong with it, please?
- aha_1980 Lifetime Qt Champion last edited by
@t0msk said in HTTP request:
@aha_1980 Thank you, I forgot :) When I need to add that libraries into .pro file?
It is easy to forget libraries to add qmake. Most of us forget. However, it isa good advice to check the libraries setting when you get undefined references for Qt libs.
Please mark your thread as "solved" | https://forum.qt.io/topic/92442/http-request/3 | CC-MAIN-2021-31 | refinedweb | 161 | 50.33 |
Last week I was writing a talk to give at Google Developers Bus and I needed to show how to integrate Flask and Google Maps API, as I did not found any extension to Google Maps I decided to create one.
One of the best things in Flask is the way it is extended by Extensions and Blueprints, by the way, Blueprints is one of the best idea I've seem in Python web frameworks, once you start working with Blueprints you want to use it everywhere (but unfortunatelly not every framework has an ellegant way to be extended)
I will start showing how the extension works and then I will explain how to build it from scratch.
Flask Google Maps
Template filter and a template global to create Google Maps from latitude and longitude
Installing
pip install flask-googlemaps
from flask import Flask from flask.ext.googlemaps import GoogleMaps app = Flask(__name__) GoogleMaps(app)
Using in templates
<div> {{ googlemap('identifier', **params)}} </div> <div> {{googlemap("map_name", lat=-0.12, lng=-0.45, markers=[(lat, lng), (lat, lng)]}} </div>
Parameters:
- identifier: The name tat will be used to identify your map (you can have multiple maps in one page) - lat: latitude to center the map - lng: Longitude to center the map - markers: a list of tuples, each tuple is a (lat, lng) marker (a pointer in the map) - zoom: percentage of the zoom - maptype: Google map type, TERRAIN or ROADMAP. defaults to ROADMAP - varname: The JS varname to bind the map, defaults to "map" - style: css style to be appended to the < div > - cls: css class to the map < div >
TODO: In near future it will be possible to pass an address as argument
Example
The template
<body> <h1>Flask Google Maps Example</h1> <h2> Google Dev Bus - Rua Quatá, 255 </h2> {% with %} {% set location=(-23.599097,-46.675903) %} {% set style="width:500px;height:500px;"%} {{ googlemap( "simple-map", location.0, location.1, markers=[location,], style=style ) }} {% endwith %} </body>
The output
Github
Screenshots and docs on Github.
How to create a Flask Extension
Flask is extendable by two patterns Extension and Blueprint
An Extension is something like a complete plugin, a distribution containing models, views, templates, static files, template globals and filters etc and usually an Extension is built of Blueprints, which is an app prototype, it can define the way an app will be when registered, exposing resources, and url rules, also the Blueprint has the capability to access the current running application to contribute with things like config values, template filters, etc.
In the Flask docs there is a great explanation on Extensions and Blueprints
Anathomy of an extension
An extension is just a Python package following the naming convention Flask_anything, with packages naming like that Flask will automatically find them in the Python PATH via the ext proxy. So instead of from flask_anything import something you can do from flask.ext.anything import something in that way the code will be very clear and explicit and you know you are dealing with a Flask extension.
Flask-Anything
root folder |__ flask_anything/ |__ templates/ |__ static/ |__ __init__.py |__ __some_module.py |__ * |__ setup.py
That is it! you can write really anything you want and it will be available throught from flask.ext.anything.some_module import FooBar
What is inside?
Usually extensions expose a main Class which will be registered in your app, there is no rule, but there is some conventions, an example:
# flask.ext.anything.some_module.py from flask import Blueprint class Anything(object): def __init__(self, app=None, **kwargs): for k, v in kwargs.items(): setattr(self, k, v) if app: self.init_app(app) def init_app(self, app): # here you get the app object and can do anything you want app.add_template_filter("pass a template filter function here") app.add_template_global("pass a template global here") app.add_url_rule("/anything/<arg>", view_func=self.something) #or even better you can register a Blueprint module = self.create_blueprint("module") another_module = self.create_another_blueprint("another_module") # then you can register many blueprints in the app app.register_blueprint(module) app.register_blueprint(another_module) def create_blueprint(self, blueprint_name): module = Blueprint(blueprint_name, __name__, template_folder="a_path_to_relative_folder") module.add_app_template_filter(...) module.add-app_template_global(...) module.add_url_rule("/something/<argument>", view_func=self.some_view) return module def some_view(self, argument): context = {'argument': argument} return self.render(self.get_template_name, context) def render(self, *args, **kwargs): return render_template(*args, **kwargs) ...
By the community convention your extension main class should receive its configurations in
__init__method and should have a lazy way to init defined as a method called
init_app, also is a good practice to create methods for things like
create_blueprint,
register_blueprint,
get_url_rulesand also a
render_templatemethod inside your Blueprint is usefull. That is because others could extend your class and overwrite them, in example to use Flask-Themes it is usefull to overwrite the
render_templatemethod.
Using your extension/Blueprint
# your_app.py from flask import Flask from flask.ext.anything.some_module import Anything app = Flask(__name__) # option 1 Anything(app) # option 2 anything = Anything() anything.init_app(app)
With the above instantiation/init_app your app will be manipulated by the extension and the views, urls, template filters etc will be available.
There is more conventions to follow as state, namespace, resource access etc, but you can find all the information on Flask docs.
If you have some idea to improve Flask-GoogleMaps, please comment! | http://brunorocha.org/python/flask/flask-google-maps-plus-how-to-write-a-flask-extension.html | CC-MAIN-2017-51 | refinedweb | 885 | 50.36 |
#include <Timeprobe_T.h>
Collaboration diagram for ACE_Timeprobe:
This class provides a lightweight implementation for measuring the time required to execute code between two time probes. When a time probe executes, it records the time, the id of the calling thread, and an event description. The event description can either be an unsigned long or a string (char *). If string are used, care must be taken cause only pointer copies are done and the string data is *not* copied. The recorded time probes can then be printed by calling <print_times>. If you have used unsigned longs as event descriptions in any of your time probes, you must have provided an event description table that maps the unsigned longs to readable strings. This map is a simple array of strings, and the event number is used as the index into the array when looking for the event description. If you have only used strings for the event description, this map is not necessary. Multiple maps can also be used to chunk up the time probes. Each one can be added by calling <event_descriptions>. Different tables are used internally by consulting the minimum_id for each table. It is up to the user to make sure that multiple tables do not share the same event id range.
Definition at line 59 of file Timeprobe_T.h. | http://www.theaceorb.com/1.3a/doxygen/ace/classACE__Timeprobe.html | crawl-003 | refinedweb | 221 | 71.34 |
Today, in the fan exchange group, a classmate said he found it
RequestsAnd fixed it:
The corresponding pictures in the chat record are:
Seeing the screenshot of this classmate, I probably know what problems he encountered and why he mistakenly thought it was a requests bug.
To explain this problem, we need to understand one problem first, that is, the two display forms of JSON strings and
json.dumpsof
ensure_asciiParameters.
Suppose we have a dictionary in Python:
Info = {'name': 'Qingnan', 'age': 20}
When we want to convert it into JSON string, we may write code like this:
import json Info = {'name': 'Qingnan', 'age': 20} info_str = json.dumps(info) print(info_str)
The operation effect is shown in the figure below, and Chinese is changed into Unicode code:
We can also add a parameter
ensure_ascii=False, let Chinese display normally:
info_str = json.dumps(info, ensure_ascii=False)
The operation effect is shown in the figure below:
The classmate believes that due to
{"name": "\u9752\u5357", "age": 20}and
{"name": "Qingnan", "age": 20}From the perspective of string, it is obviously not equal. When requests sends data through post, it does not have this parameter by default
json.dumpsFor example, omitting this parameter is equivalent to
ensure_ascii=True：
So actually
RequestsWhen post contains Chinese data, it will convert Chinese into Unicode code and send it to the server, so the server can’t get the original Chinese information at all. Therefore, it will lead to error reporting.
But in fact, this is not the case. I often tell my classmates in the group that students who are reptiles should have some basic back-end common sense so as not to be misled by this phenomenon. In order to explain why the above student’s understanding is wrong and why this is not a request bug, let’s write a post service to see if there is any difference between our post data. In order to prove that this feature has nothing to do with the network framework, I use flash, fastapi and gin to demonstrate it.
First, let’s take a look at the requests test code. Here, data in JSON format is sent in three ways:
import requests import json body = { 'name': 'Qingnan', 'age': 20 } url = '' #Send directly using JSON = resp = requests.post(url, json=body).json() print(resp) headers = { 'Content-Type': 'application/json' } #The dictionary is serialized into JSON strings in advance, and Chinese is converted into Unicode, which is equivalent to the first method resp = requests.post(url, headers=headers, data=json.dumps(body)).json() print(resp) #The dictionary is serialized into JSON strings in advance, and Chinese is reserved resp = requests.post(url, headers=headers, data=json.dumps(body, ensure_ascii=False).encode()).json() print(resp)
This test code uses three methods to send post requests, of which the first method is the self-contained method of requests
json=Parameter. The parameter value is a dictionary. Requests will automatically convert it to a JSON string. In the latter two ways, we manually convert the dictionary into JSON string in advance, and then use
data=Parameters are sent to the server. These two methods need to be specified in headers
'Content-Type': 'application/json', the server knows that the JSON string is sent.
Let’s take a look at the back-end code written by flask:
from flask import Flask, request app = Flask(__name__) @app.route('/') def index(): return {'success': True} @app.route('/test_json', methods=["POST"]) def test_json(): body = request.json MSG = f 'received post data, {body ["name"] =}, {body ["age"] =}' print(msg) return {'success': True, 'msg': msg}
The operation effect is shown in the figure below:
It can be seen that no matter which post method is used, the back end can receive the correct information.
Let’s look at the fastapi version:
from fastapi import FastAPI from pydantic import BaseModel class Body(BaseModel): name: str age: int app = FastAPI() @app.get('/') def index(): return {'success': True} @app.post('/test_json') def test_json(body: Body): MSG = f 'received post data, {body. Name =}, {body. Age =}' print(msg) return {'success': True, 'msg': msg}
The operation effect is shown in the figure below. The data sent by three kinds of post can be correctly recognized by the back end:
Let’s take a look at the back end of the gin version:
package main import ( "fmt" "net/http" "github.com/gin-gonic/gin" ) type Body struct { Name string `json:"name"` Age int16 `json:"age"` } func main() { r := gin.Default() r.GET("/", func(c *gin.Context) { c.JSON(http.StatusOK, gin.H{ "message": "running", }) }) r.POST("/test_json", func(c *gin.Context) { json := Body{} c.BindJSON(&json) msg := fmt. Sprintf ("received post data, name =% s, age =% d", JSON. Name, JSON. Age) fmt.Println(">>>", msg) c.JSON(http.StatusOK, gin.H{ "msg": fmt. Sprintf ("received post data, name =% s, age =% d", JSON. Name, JSON. Age), }) }) r.Run() }
The operation effect is as follows. The data of the three request methods are exactly the same:
From here, we can know that whether Chinese exists in the form of Unicode code or directly in the form of Chinese characters in the JSON string submitted by post, the back-end service can correctly parse it.
Why doesn’t it matter in which form Chinese is displayed in the JSON string? This is because, for a JSON string, the programming language converts it back into an object (called
Deserialization）, itself can handle them correctly. Let’s look at the following figure:
ensure_asciiParameter only controls the display style of JSON
ensure_asciiby
TrueMake sure that there are only ASCII characters in the JSON string, so all characters that are not within 128 ASCII characters will be converted. And when
ensure_asciiby
FalseThese non ASCII characters are still displayed as they are. This is like a person with or without make-up. The essence will not change. When modern programming languages deserialize them, both forms can be correctly recognized.
Therefore, if you use modern web framework to write the back end, there should be no difference between the two JSON forms. Request default
json=Parameter, equivalent to
ensure_ascii=True, any modern web framework can correctly identify the content submitted by post.
Of course, if you use C, assembly or other languages to write back-end interfaces naked, it may be different. But for people with normal IQ, who would do this?
To sum up, the problem encountered by this student is not the bug of requests, but the problem of his back-end interface itself. Maybe the back-end uses some kind of retarded web framework. The information it receives from post is a JSON string without deserialization, and the back-end programmer uses regular expressions to extract data from the JSON string. Therefore, when it is found that there is no Chinese in the JSON string, it will report an error.
In addition to the problem of sending JSON through post, I once had a subordinate who, when sending post information using scripy, couldn’t write post code, had a whim, spliced the fields sent by post into the URL, and then requested by get. It was found that data could also be obtained, similar to:
Body = {'name': 'Qingnan', 'age': 20} url = '' requests.post(url, json=body).text requests. get(' Qingnan & age = 20 ') text
So the student came to a conclusion that he thought it was a general rule that all post requests could be transferred to get requests in this way.
But obviously, this conclusion is also incorrect. This only shows that the back-end programmer of this website can make this interface compatible with two ways of submitting data at the same time, which requires the back-end programmer to write additional code. By default, get and post are two completely different request methods, and they cannot be converted in this way.
If the student knows some simple back ends, he can immediately write a back-end program to verify his conjecture.
For another example, some websites may include another URL in the URL, for example:
If you don’t have basic back-end knowledge, you may not see what’s wrong with the above website. But if you have some basic back-end knowledge, you may ask a question: what is in the website
&db=admin, belongs to parameter of, with
url=Level; Still belong to? You will be confused, and so will the backend. That’s why we need URLEncode at this time. After all, the following two writing methods are completely different:
Finally, I will summarize with a sentence in the preface of my reptile book:
Reptile is a chore. If you only know reptile, you can’t learn reptile well.
| https://developpaper.com/why-should-crawler-engineers-have-some-basic-back-end-common-sense/ | CC-MAIN-2022-33 | refinedweb | 1,440 | 61.26 |
Getting Started
Once limited to the domain of C++ and MFC programmers, Windows Services can now be a key part of your .NET applications' infrastructure. Learn how to create a Windows Service application to provide monitoring for your .NET apps.
Technology Toolbox: VB.NET
Once limited to the domain of C++ and MFC programmers, Windows Services can now be used as a key part of your .NET applications' infrastructure. Much like moving database-level code into a database tier, you can implement a core set of application services (such as database connection pooling, event logging, and auditing) and deploy them as a Windows Serviceavailable to all of your .NET applications without bloating them with redundant code. It's a good idea to implement common functionality across applications as a Windows Service for those features where an application requests a "service" (such as retrieving messages or getting a connection to a database). Otherwise, you might want to put common functionality code into a namespace in the global assembly cache (GAC).
In this article, I'll introduce you to creating a Windows Service with VS.NET 2003. I'll show you how to create a simple monitoring service for all of your .NET desktop apps. For purposes of this article, I'll define monitoring as the ability to identify critical security events (such as gates opening and closing, fire alarms activating, sprinkler systems activating, and so on) across all security applications. The monitoring service will provide all applications with the ability to signal these events and the potential to log these events (outside of the Windows event log, which sometimes can be a security requirement). The service will also provide the ability for a desktop application to communicate with it.
A Windows Service is a process that runs unattended and without a user interface. Windows Services are available only in Windows NT, Windows 2000, Windows XP, and Windows Server 2003. Windows Services run in their own process space and can be configured to start up during the OS boot process. Other desktop applications can interact with them, if you configure them that way.
You can accomplish monitoring in two ways. First, you can have the service poll each application. Unfortunately, a lot of processor time is spent polling while no monitoring activity is happening. Second, you can use an event model, where each application registers with the monitoring service and then sends monitoring events as they happen. I'll show you how to use the event model in this article.
Create a Windows Service
Start by creating a Windows Service project. Select File | New Project, then select the Windows Service template (in this example, use AppMonitor as the service name). Notice that VS.NET creates a new project with a single VB.NET file called AppMonitor.vb. Double-click on this file to bring up a designer view (see Figure 1).
Notice that you can set several properties for the service project. For example, you can tell Windows that this service will respond to shutdown, pause, and continue, and other events. You can also tell Windows to log service events such as stop and start in the Windows Event Log by setting the AutoLog property to True. Figure 1 shows the Properties page for the AppMonitor service project.
Now take a look at the code for the service by clicking on the "click here to switch to code view" link. The first thing you'll notice is that the AppMonitor class inherits from the System.ServiceProcess.ServiceBase class. This base class holds all of the events and properties necessary to define and interact with the service. VS.NET 2003 generates code for the Main subroutine, which runs when the service first loads (not runs) during the OS boot process:
<MTAThread()> _
Shared Sub Main()
' This is the main thread that gets
' loaded when all the services
' listed in the service directory get
' instantiated.
Dim ServicesToRun() As _
System.ServiceProcess.ServiceBase
' Setup the service to run
ServicesToRun = New _
System.ServiceProcess.ServiceBase() _
{New AppMonitorService}
System.ServiceProcess.ServiceBase.Run( _
ServicesToRun)
End Sub
The ServicesToRun object contains an array of service classes that you should run under the same process space (thereby conserving system resources), but can still be managed independently as services. This service array is passed to the ServiceBase.Run() method, which looks at the services and starts up any service whose Startup property is set to Automatic.
Beware that when creating your first service, the service class is named Service1 automatically. Even if you rename the service class, you still must change the line of code manually from this:
ServicesToRun = New _
System.ServiceProcess.ServiceBase() _
{New Service1}
System.ServiceProcess.ServiceBase.Run( _
ServicesToRun)
to this:
ServicesToRun = New _
System.ServiceProcess.ServiceBase() _
{New AppMonitorService}
System.ServiceProcess.ServiceBase.Run( _
ServicesToRun)
You can hook into several Windows Service events by overriding the base class routines for these eventsthere's no way in VS.NET 2003 to auto-generate these overridden events (see Listing 1 to view the code for the overridden service events in the AppMonitor service). Because the procedures are overridden, they need to match the procedure names and arguments exactly in order to compile correctly.
In the example, you respond to all of the available Windows Service events by defining overriding procedures for all possible events. In addition to start, stop, pause, and continue events, notice that there's also a custom command procedure:
Protected Overrides Sub OnCustomCommand( _
ByVal iCommand As Integer)
This procedure allows an external application to send an integer command to the service while it's running. This procedure cannot return a value, because its intended use was for primitive one-way IPC communications between a process and a service. In the AppMonitor service example, you can use OnCustomCommand to provide a way for applications to send monitoring events to the AppMonitor service. From there, merely log the command to a test log file to keep things simple. You could easily expand this for use in a production environmentfor example, you could store monitors in a database or send the messages to a message queue.
You can also send parameters to a Windows Service on startup. Notice that the OnStart routine takes an array of strings as an argument:
Protected Overrides Sub OnStart( _
ByVal args() As String)
Use a parameter in the AppMonitor example to specify the name and location of the log file. If the service is started without an argument, simply use a file in the root directory for logging. To send a parameter to a service, use the Services MMC snap-in, select properties of the service, and enter the parameter in the Start Parameters textbox (see Figure 2).
Install the Service
You need to be able to install a service now that you've created it. Add an installer to the AppMonitor project by going to the designer view of AppMonitor and clicking on the Add Installer link on the property tab (see Figure 1).
Clicking on this link adds a ProjectInstaller.vb module to the project, which contains two new components in the designer (ServiceProcessInstaller and ServiceInstaller). The ServiceProcessInstaller component for a Windows Service project holds the account type (LocalSystem, LocalUser, User, and so on) and credentials that the service will run under. The ServiceInstaller component holds information written to the Registry (HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services) about the service. This includes the name, display name, list of services depended on, and startup type (automatic, manual, or disabledmanual is the default). If your project contains multiple services, each service should have a separate ServiceInstaller component. You can also use the install and uninstall events of this component to perform additional installation work for your service.
Once these components are added and the project is compiled, the RunInstaller attribute is set to True. Only those classes with this attribute set to True will be installed when running the installer (see Listing A to view the auto-generated code and events that you can hook into within the ProjectInstaller.vb module).
You can install the service by going to the \bin directory underneath the AppMonitor project directory and running the InstallUtil program. InstallUtil is a .NET Framework utility that runs the .NET installer on the target executable (the .NET Framework directory should be part of the path by default after installing the .NET Framework). Use this command to install the AppMonitor service:
InstallUtil AppMonitor.exe
You can also use InstallUtil to uninstall the service, as long as it is stopped:
InstallUtil AppMonitor.exe /u
If you've loaded multiple versions of the .NET Framework, you need to use the framework version of InstallUtil that matches the .NET Framework you compile to. You can find InstallUtil.exe in the framework directory:
%WINDIR%\Microsoft.NET\Framework\vx.y.zzzz
Take a look at the command window result of running InstallUtil on the AppMonitor project. InstallUtil also logs this information in a file called <service_name>.InstallLog.
One last thing to note about compiling and installing Windows Services is that if you install the service from the project's \bin directory, you won't be able to recompile the service project while the service is running, because Windows will have the service executable locked.
Create a Service Wrapper Class
Now that you've created and installed the service, it's time to start work on interfacing the desktop client applications with the AppMonitor service. The easiest way to do this is by implementing the OnCustomCommand event within the service, then having each application send monitoring commands to the service (which I'll discuss in a moment). A Windows Service can only receive integer values and cannot return values. A poorly documented user service command restriction says that service custom user commands must be in the range of 128-255. Windows reserves values under 128 for system-level commands. You'll get a vague Win32 exception if you attempt to send a custom service command out of this range:
Cannot control service
<service_name> on machine ?.?
The easiest way to provide an interface with the AppMonitor service is to create a wrapper class that all of the desktop applications can use. The purpose of the wrapper class is to obfuscate the details of how and where the monitoring service is implemented. It also makes it easier to change the way the monitoring service is designed, without affecting any of the client applications. Create a MonitorWrapper class that contains enumerations for the various monitoring command codes, as well as a single method (MonitorThis()) that external applications can use to send monitoring commands (see Listing 2).
Notice that you need to reference the ServiceProcess namespace in order to access Windows Service classes:
Imports System.ServiceProcess
You can create a reference to the ServiceProcess.dll component by going to Add Reference under the References folder of the Solution Explorer for the project (see Figure 3).
Once the ServiceProcess component is referenced, you can now access the ServiceController class, which is the key to working with Windows Services. You can query and control the service, and set almost all its properties through the ServiceController object. As you can see in the MonitorThis() method, the first thing you need to do is get an instance of the ServiceController object associated with the AppMonitor service. If it exists, the service's status is examined to make sure that it's running before you send a command to the service using the ExecuteCommand() method.
Now that you've written the MonitorWrapper class, it's time to deploy it for use by other desktop applications. Normally, you would deploy it to the GAC, but for purposes of simplicity in this article, let's create a project reference to it from a sample desktop application (SecurityController).
Create a Sample App to be Monitored
The SecurityController project is a simple .NET WinForms desktop application that we'll use as a proof of concept for the AppMonitor monitoring service. This mythical security control application references the MonitorWrapper class created earlier to send service commands associated with security events. In addition, the application also includes buttons to start and stop the AppMonitor service to show how to control a Windows Service through the ServiceController object (see Listing 3).
As you can see, commands are sent to the AppMonitor service through the MonitorThis() method (in the MonitorWrapper class). You can also add start and stop buttons and code to start and stop the AppMonitor service. As discussed earlier, you control the service through the ServiceController object. The only difference between sending a command to the service and changing a service's status is that you need to start and stop a service asynchronously.
You could start a service by calling the Start() method of the ServiceController object. However, this doesn't guarantee that the service will start. After calling Start(), you need to make a call to the WaitForStatus() method, which waits for a specified time span (or indefinitely, if no time span is specified) for the status to change to the desired state. If the WaitForStatus() method times out, an exception is thrown, which needs to be caught. This same logic also goes for stopping, pausing, or resuming a service.
Debugging a Windows Service is just like debugging any external process. Within the IDE, you can attach to a running Windows Service by using the Tools | Debug Process command. Bring up the code within the IDE, set your breakpoints, and debug as you would a normal application. Keep in mind that you're debugging a "live" process when debugging a Windows Service. If you hit a breakpoint, the service stops on the machine and doesn't respond to any other events. If you close the debugger/IDE without resuming the process, the service reverts to a stopped state and could result in instability within the service.
Now that you've deployed a simple monitoring service, you can see how you can extend this model easily. The fact is, you probably wouldn't use this kind of monitoring design in a production environment because it relies on file I/O and simplistic integer service commands. A more elegant (but complex) design would be to spin off a separate thread within the OnStart() method of the service. This thread would initialize a message queue for application monitoring commands. You could then revise the MonitorWrapper to communicate with the message queue instead of executing an integer command on the AppMonitor service itself. After the new Windows Service is ready to deploy, you could compile, reversion, and deploy a new MonitorWrapper class to the GAC to run side by side with the original version. You could give the new Windows Service a version-unique name so it could run side by side with the old AppMonitor service as well. You would merely need to recompile desktop applications with a reference to the new MonitorWrapper class in order to take advantage of the new monitoring design.
You now have the basics for developing Windows Services in .NET. As you can see, VS.NET 2003 makes it simple to create and deploy services, and the ability to hook into service events gives you a strong foundation for building even the most complex Windows Service in any .NET language. You can extend this simple architecture easily to make it more robust for your high-capacity production environment. This is a Getting Started column, so I'll shelve how to extend the AppMonitor service using threads and MSMQ for a future article. Stay tuned for this AppMonitor service upgrade, which will combine the use of some of the .NET technologies that I've written about in VSM over the past six months (including threads and MSMQ) with Windows Services, to provide an exciting monitoring architecture.
Printable Format
> More TechLibrary
I agree to this site's Privacy Policy.
> More Webcasts | https://visualstudiomagazine.com/articles/2005/02/01/build-your-first-net-windows-service.aspx | CC-MAIN-2018-13 | refinedweb | 2,642 | 53.31 |
03 September 2008 23:59 [Source: ICIS news]
LONDON (ICIS news)--The majority of European paraffin wax players confirmed increases of €80-100/tonne ($116-145/tonne) for September on severe market tightness, despite some buyer unrest at rising prices, players said on Wednesday.?xml:namespace>
Consequently, 52-54°C grade was at levels of €1,260-1,320/tonne FD (free delivered) NWE (northwest Europe), 56-58°C was at €1,320-1,380/tonne FD NWE and 60-62°C material at €1,330-1,420/tonne FD NWE.
One of the largest candle producers in ?xml:namespace>
Despite the price reduction in crude oil, the lack of availability was allowing suppliers to announce more price hikes, the source said.
Some other consumers were adamant prices had rolled over in September, in line with falling crude oil prices.
One source reported that one seller had dropped its prices in September although this could not be confirmed.
Common uses for paraffin wax include candles, corrugated boxes, waxed papers, frozen food cartons and wrappers.
($1 = €0.69)
For more on p-wax | http://www.icis.com/Articles/2008/09/03/9153969/europe-september-paraffin-wax-rises-80-100t.html | CC-MAIN-2014-10 | refinedweb | 182 | 60.55 |
NAME
kernacc, useracc - check memory regions for accessibility
SYNOPSIS
#include <sys/param.h> #include <sys/proc.h> #include <vm/vm.h> #include <vm/vm_extern.h> int kernacc(void *addr, int len, int rw); int useracc(void *addr, int len, int rw);
DESCRIPTION
The kernacc() and useracc() functions check whether operations of the type specified in rw are permitted in the range of virtual addresses given by addr and len. The possible values of rw are any bitwise combination of VM_PROT_READ, VM_PROT_WRITE and VM_PROT_EXECUTE. kernacc() checks addresses in the kernel address space, while useracc() considers addr to represent an user space address. The process context to use for this operation is taken from the global variable curproc.
RETURN VALUES
Both functions return boolean true if the type of access specified by rw is permitted. Otherwise boolean false is returned.
BUGS
The process pointer should be passed in as an argument to useracc(). | http://manpages.ubuntu.com/manpages/karmic/man9/kernacc.9freebsd.html | CC-MAIN-2013-20 | refinedweb | 151 | 50.02 |
As I’ve seen in my previous post, the interest in functional programming is high. This is the reason I want to write an introduction about it.
I work a lot in Haskell and Java in my free time. The idea to combine both of these languages in Java was a dream come true. After this introduction, I hope you will feel the same.
What is functional programming, really?
You might have heared about functional programming (fP) and how great it is to reduce your LOC and to enhance the readability of your code. But what does it really mean to program functional and what are the main differences to OOP?
1. All variables are final
Lets look at this function to greet some users. First of, it is written OO. public String greet(List<String> names) { String greeting = "Welcome "; for(String name : names) { greeting += name + " "; // We don't care about the last space right now. } greeting += "!"; return greeting; }
This is a perfectly valid function to create such a greet String in Java.
But if you you are fP, this won’t work. You change the state of greeting, which is not allowed in fP. So if you try to make greeting final, you would get an error. Every time you use += with that String, you change its state.
What you basically do in fP is the concatination of all names in one line into one String.
public String greet(List<String> names) { final String reducedString = "Welcome " + names.get(0) + " " + names.get(1) + " " + ... + names.get(names.size()-1) + " "; return reducedString + "!"; }
If you think think that this looks nasty, you’re right! But there is a fP function to make this nicer.
I will give you the right fP function here. Don’t worry if you don’t understand it now, we will talk about all of this in part 3
public String greet(List<String> names) { String greeting = names .stream() .map(name -> name + " ") .reduce("Welcome ", (acc, name) -> acc + name); return greeting + "!"; }
The good think about final variables is that their value is always the same. This makes debugging and testing so much easier!
2. Don’t use global variables (and forget about side effects)
I’ve choosen the example of a global time object. You write a static function, which returns the current time as a String. A OO function could look like this:
public class Utils { private static Time time; public static String currTime() { return time.now().toString(); } }
If you use
currTime twice, the result will be different, because the time will be different. Although we had the same input (which is none),
currTime had two different results!
This can’t happen in fP. Every method only depense on its parameters and on nothing else! So if we want to do something like this, the Time object has to be a parameter of
currTime:
public class Utils { public static String currTime(Time time) { return time.now().toString(); } }
This might seem odd in the OO world, but it has some benefits.
On one hand, it is much easier to read the code. If you know that a method only relies on its parameter, you don’t have to look for global variables that do the magic in your method. On the other hand, testing is much easier too! When you want to test the fP
currTime method, you can mock the Time object. In the OO version, it’s really difficult to mock the static Time object.
3. Use functions as parameters
In fP, functions can be arguments of another function! How cool is that? Just think of a function which adds 1 to every number of a
List<Integer>. How would you do that OO? Here’s a snippet:
public List<Integer> addOne(List<Integer> numbers) { List<Integer> plusOne = new LinkedList<>(); for(Integer number : numbers) { plusOne.add(number + 1); } return plusOne; }
Now you have to handle two lists. This can be very confusing and leads to errors. There is also the chance to change the state of numbers. This could lead to problems in later parts of the program
In fP, you can map a function with every element of a List. In this example this means, that you want to “map” number+1 to every item in the list and store this in a new List.
Don’t worry if you don’t understand all of it now, we will learn about this in part 3. The fP method would look like this:
public List<Integer> addOne(List<Integer> numbers) { return numbers .stream() .map(number -> number + 1) .collect(Collectors.toList()); }
This reduces the number of variables and therefore the places where you can make errors. Here, you create a new list and leave numbers like it is.
Conclusion
I hope you can see the benefits of fP. Later on, you will learn to truly appreciate them. Final variables are a big help in terms of multi-threading, the lack of global variables improves the testability and functions as parameters improve the code quality.
And don’t worry, in the beginning you can mix OOP and fP in your code.
In the next part, we will talk about functions as parameters. Therefore, I will introduce anonymous function(lambdas) and method references.
I hope you liked this short introduction in the big topic of functional programming. Please write me when something’s not clear. Or are there any reason for you to hate functional programming at all? I would love to discuss these topics with you.
{{ parent.title || parent.header.title}}
{{ parent.tldr }}
{{ parent.linkDescription }}{{ parent.urlSource.name }} | https://dzone.com/articles/functional-programming-in-java-8-part-0-motivation | CC-MAIN-2017-26 | refinedweb | 928 | 74.9 |
Metroplex a Redis based spark/connection registry for Primus.
Metroplex is released in the npm registry and can therefor be installed using:
npm install --save metroplex
Once you've installed the module you need to tell Primus to use the plugin which
is done using the
primus.use method:
'use strict';var http =Primus =primus = http transformer: 'sockjs' ;primus;
In the example above you've seen how to add the plugin to your Primus server but not how to configure it. We have various of options that can be configured in this plugin:
ioredisclient.
metroplex.
300000ms
alivekey in Redis. This time is subtracted from the set
intervalso we update the key BEFORE it expires. Defaults to
2000ms. it.
These options should be provided in the options object of the Primus server:
primus = httptransformer: 'sockjs'namespace: 'metroplex'redis:;primus;
The orchestration is all done using the
metroplex library which is bundled in
this plugin. The Metroplex instance is exposed on the
Primus instance when you
use this plugin:
primusmetroplex;
The following public methods are available.
metroplex
List all the servers in our current registry.
metroplex;
metroplex
Get the server for the given spark id. It does not check if the spark is hosted on the current server. That's up to the developer to implement.
metroplex;
metroplex
Get the servers for each id in the given
sparks array. It will return an
object and just like
metroplex.spark it does not check if the spark is hosted
on the current server.
If you load the
omega-supreme
plugin before
metroplex, you can use some additional convenience methods.
These methods are added to the
primus.forward object:
forward
Broadcast a message to all sparks in the cluster.
forward;
forward.sparks(ids, msg, fn)
Send a message to a set of sparks in the cluster.
forward;
forward.spark(id, msg, fn)
Send a message to a single spark in the cluster.
forward; | https://www.npmjs.com/package/metroplex | CC-MAIN-2017-39 | refinedweb | 319 | 73.78 |
Currently working on a Median calculation tool. This tool is similar to the one I posted on a previous post involving selecting a city and zooming into it. In this case, we have to type in a country name, where the tool will then select all the cities in that country, sort the POP_RANK of the cities in that country, and calculate the median POP_RANK for that country. I was able to complete the select and zoom aspect but I am not entirely sure how to create a list/search cursor which will allow us to input a calculation. Is there a specific way I should approach this? Any and all help is appreciated!! Thank you
import arcpy
from arcpy import mapping
#sets the workspace
mxd = arcpy.mapping.MapDocument("CURRENT")
df = arcpy.mapping.ListDataFrames(mxd, "Layers")[0]
fc = ("N:/data2016/Lab13/cities.shp")
cities = arcpy.mapping.ListLayers(mxd, "Cities")[0]
cities.showLabels = True
def countryList():
country = arcpy.GetParameterAsText(0)
country_Layer = arcpy.MakeFeatureLayer_management(fc, "country_lyr")
arcpy.SelectLayerByAttribute_management(cities, "NEW_SELECTION", "CNTRY_NAME = '{}' ".format(country))
arcpy.mapping.ListDataFrames(mxd)[0].zoomToSelectedFeatures()
arcpy.RefreshActiveView()
arcpy.Delete_management("country_lyr")
SearchCursor—Help | ArcGIS for Desktop example 2 shows how to ge the unique values.. if you leave out the set(...) bit, you have all the values, which then you can then use a python sort, get the len(gth) and if len is divisible by 2 (mod), just take the average of the middle 2 (from len/2 and len/2 +1) otherwise if len is odd, just take the middle one.
alternately that field can be read and converted to a numpy array for which there are median methods for data with and without nodata values. | https://community.esri.com/thread/176516-median-calculation-tool | CC-MAIN-2020-40 | refinedweb | 279 | 50.02 |
Simple webpack config to build javascript, sass and css using NPM and ASP.NET Core
Luke Lowrey
Originally published at
lukencode.com
on
・3 min read
I have been working on a ASP.NET Core project that requires me to build and publish sass stylesheets, css and javascript. I wanted to streamline the process so I put together this simple webpack setup to automate what had been a couple of manual steps.
Webpack and its various plugins require Node.js to run and NPM to install. The package.json file tracks the node dependencies for the project. The packages I am using for Webpack are installed as devDependencies and can be added using the npm install command with the -D flag eg:
npm install webpack -D
This is my package.json file:
I will explain a couple of the packages I am including here when we look at my actual webpack config. You can install all packages using “npm install” in the directory of package.json. I am also using npm to run the webpack scripts. I found this a much simpler option than including extra grunt/gulp scripts. The scripts are pretty straight forward build and build:dev run webpack with flags to tell it the environment and whether it should minimize the output. Th watch script is useful during development as it will automatically rebuild assets when it detects a file has changed.
This is the webpack config script that is being run by npm. It reads a single “entry” javascript file and builds any javascript, css or sass included to the specified output path.
The work is done by the loaders configured in the modules section. Babel is a popular javascript compiler which allows you to use ES2015 and other things easily on the web.
The css and sass rules are using the ‘extract-text-webpack-plugin’ to pull out the resulting css into a separate file (‘site.css’). Webpack allows for some pretty fancy setups where css is rendered inline or bundled with javascript components like react and vuejs but for my purposes I am going with a single seperate css file.
The entry file will include javascript import or require statements for dependencies in addition to any javascript for the application. This includes the sass or css dependencies although this webpack script is configured to export those to a separate file. Example import statements in app.js:
import '../css/theme.scss' import '../vendor/tagsinput'
The scripts so far are completely independent to the ASP.NET Core application and work well being run as npm scripts from the console:
npm run build npm run watch
We can integrate the into the .net build and publish workflow by adding some steps the the build process in the projects .csproj file. These scripts come from good post on codeburst.io on webpack.
<Target Name="DebugRunWebpack" BeforeTargets="Build" Condition=" '$(Configuration)' == 'Debug' And !Exists('wwwroot\dist') "> <!--." /> <!-- In development, the dist files won't exist on the first run or when cloning to a different machine, so rebuild them if not already present. --> <Message Importance="high" Text="Performing first-run Webpack build..." /> <Exec Command="npm run build:dev" /> </Target> <Target Name="PublishRunWebpack" AfterTargets="ComputeFilesToPublish"> <Exec Command="npm install" /> <Exec Command="npm run build" /> <ItemGroup> <DistFiles Include="wwwroot\dist\**" /> <ResolvedFileToPublish Include="@(DistFiles->'%(FullPath)')" Exclude="@(ResolvedFileToPublish)"> <RelativePath>%(DistFiles.Identity)</RelativePath> <CopyToPublishDirectory>PreserveNewest</CopyToPublishDirectory> </ResolvedFileToPublish> </ItemGroup> </Target>
The “DebugRunWebpack” target will build the assets in dev mode if they dont already exist. “PublishRunWebpack” will build and include the files when running dotnet publish. This is useful for automated build pipelines such as visual studio online.
The setup here is very basic and a good starting point - especially if you are not using a framework such as react. Functionality that could be added depending on the project is separating the vendor assets into a different file/process as well as adding linting, source maps and more to the webpack config.
Workspace Wednesday: Show off your desk/computer setup!
Let’s share pics of everybody’s setups. Feel free to add details about your ha...
Show Dev: Top HN stories sorted by votes
Srebalaji Thirumalai -
aria-live, accessibility tips 🦮
Yaser Adel Mehraban -
I am a professional JavaScript developer, and I recently did a pair programming session. Here's what I got.
Lucas Chen -
| https://dev.to/lukencode/simple-webpack-config-to-build-javascript-sass-and-css-using-npm-and-aspnet-core-3m4h | CC-MAIN-2019-39 | refinedweb | 717 | 55.74 |
A library for SoftLayer's API
Project description
This library provides a simple Python client to interact with SoftLayer’s XML-RPC API.
A command-line interface is also included and can be used to manage various SoftLayer products and services.
Documentation
Documentation for the Python client is available at Read the Docs .
Additional API documentation can be found on the SoftLayer Development Network:
Installation
Install via pip:
$ pip install softlayer
Or you can install from source. Download source and run:
$ python setup.py install
Another (safer) method of installation is to use the published snap. Snaps are available for any Linux OS running snapd, the service that runs and manage snaps. Snaps are “auto-updating” packages and will not disrupt the current versions of libraries and software packages on your Linux-based system. To learn more, please visit:
To install the slcli snap:
$ sudo snap install slcli (or to get the latest release) $ sudo snap install slcli --edge
The most up-to-date version of this library can be found on the SoftLayer GitHub public repositories at. For questions regarding the use of this library please post to Stack Overflow at and your posts with “SoftLayer” so our team can easily find your post. To report a bug with this library please create an Issue on github.:.
Basic Usage
Advanced Usage
You can automatically set some parameters via environment variables with by using the SLCLI prefix. For example
$ export SLCLI_VERBOSE=3 $ export SLCLI_FORMAT=json $ slcli vs list
is equivalent to
$ slcli -vvv --format=json vs list
Getting Help
Bugs and feature requests about this library should have a GitHub issue opened about them.
Issues with the Softlayer API itself should be addressed by opening a ticket.
Debugging
To get the exact API call that this library makes, you can do the following.
For the CLI, just use the -vvv option. If you are using the REST endpoint, this will print out a curl command that you can use, if using XML, this will print the minimal python code to make the request without the softlayer library.
$ slcli -vvv vs list
If you are using the library directly in python, you can do something like this.
import SoftLayer import logging class invoices(): def __init__(self): self.client = SoftLayer.Client() debugger = SoftLayer.DebugTransport(self.client.transport) self.client.transport = debugger def main(self): mask = "mask[id]" account = self.client.call('Account', 'getObject', mask=mask); print("AccountID: %s" % account['id']) def debug(self): for call in self.client.transport.get_last_calls(): print(self.client.transport.print_reproduceable(call)) if __name__ == "__main__": main = example() main.main() main.debug()
System Requirements
- Python 3.5, 3.6, 3.7, 3.8, or 3.9.
- A valid SoftLayer API username and key.
- A connection to SoftLayer’s private network is required to use our private network API endpoints.
Python 2.7 Support
As of version 5.8.0 SoftLayer-Python will no longer support python2.7, which is End Of Life as of 2020 . If you cannot install python 3.6+ for some reason, you will need to use a version of softlayer-python <= 5.7.2
Python Packages
- prettytable >= 2.0.0
- click >= 7
- requests >= 2.20.0
- prompt_toolkit >= 2
- pygments >= 2.0.0
- urllib3 >= 1.24
This software is Copyright (c) 2016-2021 SoftLayer Technologies, Inc.
See the bundled LICENSE file for more information.
Project details
Release history Release notifications | RSS feed
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages. | https://pypi.org/project/SoftLayer/6.0.2/ | CC-MAIN-2022-27 | refinedweb | 587 | 58.18 |
COSMOSDataCollectionMeeting20071113
From Eclipsepedia
Agenda
- Status updates and agenda changes
- Review action items
- F2F wrapup and followup items:
- Code Refactoring (Hubert)
- Annotations (Joel)
- Error Logging (Jack/ Martin)
Attendees
- Don Ebright
- Joel Hawkins
- Hubert Leung
- Jack Devine
- Martin Simmonds
- Paul Stratton
- John Todd
- Maosheng Liang
- Bill Muldoon
- Mark Weitzel
Discussion
- Hubert has checked in the code from the sandbox. He will build an i7 driver with this code and schedule a call for Thursday 9AM-11AM EST.
- Joel described the state of his annotations work - link. We had some confusion regarding wiring terminology and namespace for bug 209244. We agreed to call the automated process autowire for now. Mark wanted to change the namespace from wsdm to a package-oriented name. We need an alternative to WS-Addressing to provide support for CMDBf. Mark updated the CMDBf addressing bug 209246 to sev 1 blocker and will discuss with Balan.
- Martin discussed some questions regarding the implementation of the error logging enhancement. He suggested creating a web service appender for log4j. He also expressed a requirement for the ability to remotely set logging levels.
Action Items
- Hubert to build a driver and schedule a call for Thursday 9AM-11AM EST.
- Mark to repoen the enhancement request to add a requirement for Joel to provide documentation of the new annotations support. | http://wiki.eclipse.org/COSMOSDataCollectionMeeting20071113 | CC-MAIN-2014-35 | refinedweb | 217 | 54.83 |
(For more resources related to this topic, see here.)
The PlayStation Mobile (PSM) SDK represents an exciting opportunity for game developers of all stripes, from hobbyists to indie and professional developers. It contains everything you need to quickly develop a game using the C# programming language. Perhaps more importantly, it provides a market for those games. If you are currently using XNA, you will feel right at home with the PSM SDK.
You may be wondering at this point, Why develop for PlayStation Mobile at all? Obviously, the easiest answer is, so you can develop for PlayStation Vita , which of itself will be enough for many people. Perhaps, though the most important reason is that it represents a group of dedicated gamers hungry for games. While there are a wealth of games available for Android, finding them on the App Store is a mess, while supporting the literally thousands of devices is a nightmare. With PlayStation Mobile, you have a common development environment, targeting powerful devices with a dedicated store catering to gamers.
We are now going to jump right in and get those tools up and running. Of course, we will also write some code and show how easy it is to get it running on your device. PlayStation Mobile allows you to target a number of different devices and we will cover the three major targets (the Simulator, PlayStation Vita, and Android). You do not need to have a device to follow along, although certain functionality will not be available on the Simulator.
One thing to keep in mind with the PlayStation Mobile SDK is that it is essentially two SDKs in one. There is a much lower level set of libraries for accessing graphics, audio, and input, as well as a higher-level layer build over the top of this layer, mostly with the complete source available. Of course, underneath this all there is the .NET framework. In this article, we are going to deal with the lower level graphics interface. If the code seems initially quite long or daunting for what seems like a simple task, don't worry! There is a much easier way that we will cover later in the book.
Accessing the PlayStation Mobile portal
This recipe looks at creating a PSM portal account. For this process it is mandatory to download and use the PSM SDK.
Getting ready
You need to have a Sony Entertainment Network (SEN) account to register with the PSM portal. This is the standard account you use to bring your PlayStation device online, so you may already have one. If not, create one at before continuing.
How to do it...
Open a web browser and log in to. Locate and click on the Register button.
Agree to the Terms and Conditions. You need to scroll to the bottom of the text before the Agree button is enabled. But, you always read the fine print anyways... don't you?
Finally select the e-mail address and language you want for the PlayStation Mobile portal. You can use the same e-mail you used for your SEN account. Click on Register.
An e-mail will be sent to the e-mail account you used to sign up. Locate the activation link and either click on it, or copy and paste into a browser window:
Your account is now completed, and you can log in to the PSM developer portal now.
How it works...
A PlayStation Mobile account is mandatory to download the PSM tools. Many of the links to the portal require you to be logged in before they will work. It is very important that you create and activate your account and log in to the portal before continuing on with the book! All future recipes assume you are logged in to the portal.
Installing the PlayStation Mobile SDK
This recipe demonstrates how to install the PlayStation Mobile SDK.
Getting ready
First you need to download the PlayStation Mobile SDK; you can download it from.
How to do it...
Locate the installation file you downloaded earlier and double-click to launch the installer. Say yes to any security related questions.
Take the default settings when prompting, making sure to install the runtimes and GTK# libraries.
The installer for the Vita drivers will now launch. There is no harm in installing them even if you do not have a Vita:
Installation is now complete; a browser window with the current release notes will open.
How it works...
The SDK is now installed on your machines. Assuming you used default directories, the SDK will be installed to C:\Program Files (x86)\SCE\PSM if you are running 64 bit Windows, or to C:\Program Files\SCE\PSM if you are running 32 bit Windows. Additionally all of the documentation and samples have been installed under the Public account, located in C:\Users\Public\Documents\PSM.
There's more...
There are a number of samples available in the samples directory and you should certainly take a moment to check them out. They range in complexity from simple Hello World applications, up to a full blown 3rd person 3D role playing game (RPG). They are, however, often documented in Japanese and often rely on other samples, making learning from them a frustrating experience at times, at least, for those of us who do not understand Japanese!
Creating boilerplate code will now be created; hit the F5 key or select the Run | Start Debugging menu to run your code in the Simulator.
Not much to look at, but it's your first running PlayStation Mobile application! Now let's take a quick look at the code it generated:
using System; using System.Collections.Generic; using Sce.PlayStation.Core; using Sce.PlayStation.Core.Environment; using Sce.PlayStation.Core.Graphics; using Sce.PlayStation.Core.Input; namespace Ch1_Example1 { public class AppMain{ private static GraphicsContext graphics; public static void Main (string[] args){ Initialize (); while (true) { SystemEvents.CheckEvents (); Update (); Render (); } } public static void Initialize (){ graphics = new GraphicsContext (); } public static void Update (){ var gamePadData = GamePad.GetData (0); } public static void Render () { graphics.SetClearColor (0.0f, 0.0f, 0.0f, 0.0f); graphics.Clear (); graphics.SwapBuffers (); } } }
How it works...
This recipe shows us the very basic skeleton of an application. Essentially it loops forever, displaying a black screen.
private static GraphicsContext graphics;
The GraphicsContext variable represents the underlying OpenGL context. It is used to perform almost every graphically related action. Additionally, it contains the capabilities (resolution, pixel depth, and so on) of the underlying graphics device.
All C# based applications have a main function, and this one is no exception. Within Main() we call our Initialize() method, then loop forever, checking for events, updating, and finally rendering the frame. The Initialize() method simply creates a new GraphicsContext variable. The Update() method polls the first gamepad for updates.
Finally Render() uses our GraphicsContext variable to first clear the screen to black using an RGBA color value, then clears the screen and swaps the buffers, making it visible. Graphic operations in PSM SDK generally are drawn to a back buffer.
There's more...
The same process is used to create PlayStation Suite library projects, which will generate a DLL file. You can use almost any C# library that doesn't rely on native code (pInvoke or Unsafe); however, they need to be recompiled into a PSM compatible DLL format.
Color in the PSM SDK is normally represented as an RGBA value. The RGBA acronym stands for red, green, blue, and alpha. Each is an int variable type, with values ranging from 0 to 255 representing the strength of each primary color. Alpha represents the level of transparency, with 0 being completely transparent and 256 being opaque.
This recipe is going to create an application that loads a texture from an image file and displays it centered on the screen. This example is actually rather daunting, throwing quite a bit of information at a new developer. Don't worry if it seems overly complex for now; by the end of the book it will make more sense. If you feel overwhelmed, I recommend you continue the book and revisit this recipe later.
Getting ready
Following the instructions presented in the Creating a simple game loop recipe, create a new solution. I have named mine as Ch1_Example2.
How to do it...
First, we need to add an image file to our project to use as a texture. This can be done by right-clicking our project in the Solution panel and selecting Add | Add Files... from the menu, as shown in the following screenshot:
Now, we need to tell PSM Studio what to do with this file. Select our newly added image, right-click on it, and select Build Action | Content.
Now, enter the following code:
using System; using System.Collections.Generic; using Sce.PlayStation.Core; using Sce.PlayStation.Core.Environment; using Sce.PlayStation.Core.Graphics; using Sce.PlayStation.Core.Input; namespace Ch1_Example2 { public class AppMain { private static GraphicsContext _graphics; private static Texture2D _texture; private static VertexBuffer _vertexBuffer; private static ShaderProgram _textureShaderProgram; private static Matrix4 _localMatrix; private static Matrix4 _projectionMatrix; private static Matrix4 _viewMatrix; private static float _viewportWidth; private static float _viewportHeight; public static void Main (string[] args){ Initialize (); while (true) { SystemEvents.CheckEvents (); Update (); Render (); } } public static void Initialize (){ _graphics = new GraphicsContext (); _viewportWidth = _graphics.GetFrameBuffer().Width; _viewportHeight = _graphics.GetFrameBuffer().Height; _texture = new Texture2D("/Application/FA-18H.png",false); _vertexBuffer = new VertexBuffer(4,VertexFormat. Float3,VertexFormat.Float2); _vertexBuffer.SetVertices(0,new float[] { 1,0,0, _texture.Width,0,0, _texture.Width,_texture.Height,0, 0,_texture.Height,0}); _vertexBuffer.SetVertices(1,new float[]{ 0.0f,0.0f, 1.0f,0.0f, 1.0f,1.0f, 0.0f,1.0f}); _textureShaderProgram = new ShaderProgram("/Application/ shaders/Texture.cgx"); _projectionMatrix = Matrix4.Ortho( 0,_viewportWidth, 0,_viewportHeight, 0.0f,32768.0f); _viewMatrix = Matrix4.LookAt( new Vector3(0,_viewportHeight,0), new Vector3(0,_viewportHeight,1), new Vector3(0,-1,0)); _localMatrix = Matrix4.Translation(new Vector3(-_texture. Width/2,-_texture.Height/2,0.0f)) * Matrix4.Translation(new Vector3(_viewportWidth/2,_ viewportHeight/2,0.0f)); } public static void Update (){ var gamePadData = GamePad.GetData (0); }.DrawArrays(DrawMode.TriangleFan,0,4); _graphics.SwapBuffers (); } } }
How it works...
Phew! That sure seemed like a lot of code to simply display a single image on screen, didn't it? The truth is, you did a lot more than just load and draw a texture. Let's jump in and look at exactly what we just created.
First, we declared the following variables, in addition to our existing GraphicsContext variable:
_texture is our Texture2D object that is going to hold our textured image.
_vertexBuffer is a VertexBuffer object that holds the 3D quad geometry we are going to map our texture on.
_shaderProgram is a ShaderProgram variable, the texture shader needed to render our texture. The GraphicsContext variable requires at least one. Fortunately, a simple one with the extension .cgx was created for you already by PSM Studio when you created the project.
_localMatrix, _projectionMatrix, and _viewMatrix are Matrix4 objects, representing the textured object's position.
_viewportWidth and _viewportHeight contain the dimensions of our window.
The bulk of our activity is in the Initialize() method. Once again, we create a GraphicsContext variable, and then store the dimensions of the frame buffer in the _viewportHeight and _viewportWidth variables. Next, we create our Texture2D object, passing the constructor the filename and whether or not we want a mipmap generated.
Next, we create a _vertexBuffer object, which is going to be a fullscreen quad we can draw our texture on. We make two calls to SetVertices(). The first call is defining the x, y, and z float variables that make up the four vertices of the fullscreen quad. The second SetVertices function call is four x and y texture coordinates. Texture coordinates are represented with a value from 0 to 1.
Next, we create our _textureShaderProgram function using the default shader PSM Studio created for us. We will cover shaders in more detail later in this article.
Finally, we set up the _projectionMatrix, _viewMatrix, and _localMatrix objects. The projection matrix is an orthographical matrix that represents our screen. The view matrix represents the camera within the world, using Matrix4.LookAt. LookAt(), which requires 3 vectors, the first representing your eye's location in 3D space, the second, the 3D point you are looking at, and the third, the direction where "UP" is, in this case in the Y direction. Finally, the local matrix represents the position of texture, which we want to be centered in the middle of the screen.
Now, let's take a look at the Render() function, where our texture is going to be displayed to the screen. As before, we set the clear color to black and clear the buffer. Next, we generate our worldViewProjection matrix by multiplying our projection, view and local matrices together. We then bind our worldViewProjection matrix to our shader program and then set our shader program to the GraphicsContext variable. We also set our VertexBuffer object and Texture2D object to the GraphicsContext variable. The DrawArrays() call is what ties it all together, using our worldViewMatrix to transform our vertices from our VertexBuffer object and applying our texture map, rendering it all to the active buffer. Finally, we make that buffer visible, which draws it on screen.
Here is our program in action, rendering our sprite centered to the screen:
Again, if that seemed overly complex, don't panic! Most of this code only needs to be written once, and you have the option of not working at this low a level if you should choose!
There's more...
Build actions will be executed when your project is compiled, copying the content to the appropriate folder, performing whatever conversions are required. If you are used to XNA, this is similar to the functionality of the content pipeline, but not programmable.
Why is there 3D in my 2D?
The bulk of this example was actually going through the process of faking a 2D environment using 3D. The reason is modern GPUs are optimized to work in 3D. If you look at the code to most modern 2D libraries, they are actually working in 3D. If you were to work with native 2D graphics libraries, your performance would be abysmal.
An explanation of 3D mathematics is beyond the scope of this book, but the Kahn Academy (see) is an excellent free resource with thousands of video tutorials.
The sprite I used for this example and throughout this book is from a wonderful free sprite library made available by GameDev.net user Prince Eugn. You can find more information and download the sprite pack at.
"Hello World" drawing text on an image
This recipe dynamically creates and displays a texture with text created using the imaging APIs.
Getting ready
This recipe builds on the code from the last recipe. Add the following using statement to the beginning of the program code:
For the complete source code for this example, see Ch1_Example3.
using Sce.PlayStation.Core.Imaging
How to do it...
In the Initialize() function, instead of loading a texture from the file, we will create one using the following code:
Image img = new Image(ImageMode.Rgba,new ImageSize(500,300),new ImageColor(0,0,0,0)); img.DrawText("Hello World", new ImageColor(255,255,255,255), new Font(FontAlias.System,96,FontStyle.Italic), new ImagePosition(0,150)); _texture = new Texture2D(500,300,false,PixelFormat.Rgba); _texture.SetPixels(0,img.ToBuffer());
Next, update the Render() method in the following code in which the bolded portions represent the changes:.Enable(EnableMode.Blend); _graphics.SetBlendFunc(BlendFuncMode.Add, BlendFuncFactor. SrcAlpha, BlendFuncFactor.OneMinusSrcAlpha); _graphics.DrawArrays(DrawMode.TriangleFan,0,4); _graphics.SwapBuffers (); }
How it works...
Instead of loading a texture from an image file, we create an image dynamically. In the Image constructor, we pass the type of image we want created, the dimensions and the background color to fill it with.
Next, we draw on our newly created image using the DrawText() function, which takes as parameters the text to draw, the color to draw it in, the font to use (there is only one option, System) and the position to draw the text at. We then create a Texture2D object to hold our image. We pass its constructor the image dimensions, whether we want to generate a mipmap or not, as well as the pixel format to use. Finally, we assign the pixel data to our _texture object by calling SetPixel() function and passing in a byte array generated by calling ToBuffer() function on our image.
We had to make the change to the Render() method to support blending using the alpha channel, or background would not be properly visible through the transparent portions of the text. Run the code again without EnableMode.Blend enabled and your text will be illegible.
Now if we run our application, we will see the following screenshot:
There's more...
You can also load a font by name instead of using the built in system font. If you need precise control over your text positioning or size, be sure to check out the FontMetrics and CharMetrics classes in the documentation.
Deploying to PlayStation Mobile certified Android devices
This recipe covers deploying an application to an Android device. Running on an Android device requires a developer license that you can purchase in the PSM portal.
Getting ready
You need to have installed the PlayStation Mobile SDK to have access to required files. Of course you will also require a PlayStation Mobile compatible Android device. Make sure the Android ADB driver for your phone is installed on your computer; you can download a generic version from Google's Android development website if required.
How to do it...
Attach your Android phone by USB to your computer. It may install a driver at this point, let it.
Open a Command Prompt (Start | Run and type cmd.exe) and type "%SCE_PSM_ SDK%/tools/update_psmdevassistant.bat" including the quotes. This will install the PSM Development Assistant on your device.
On your device, locate and run the PSM Development Assistant application.
On your computer, in the PlayStation Mobile folder in the Start menu, load Publishing Utility.
Now you need to create a Publisher Key; you will only have to do this once. First click the Key Management tab, then the Generate Publisher Key button. Name your key and then enter your login information for the PSM portal. A key will be generated for you.
Click on the Generate App Key Ring button. In the app.xml field locate the App.xml file of the project you want to run on your device and then click on OK. You will have to authenticate with your SEN ID again. If all goes well, your app will now be listed in the Registered App Key Ring list.
Now fire up your project in PSM Studio. Make sure that you have the PlayStation Mobile Development Assistant running on your device and your phone is connected by a USB connection. Set Android as your target using the Project | PlayStation Mobile Device Target menu item and select your phone device.
Run your application by pressing the F5 key or choosing Run or Debug from the menu and your application will be copied to your Android device and run.
There's more....
You need to make sure that USB debugging is enabled on your Android device. This varies from device to device, but is generally located in the Settings | Developer Options | USB debugging menu.
I ran into an error when trying to add my application to the key ring. To fix this, I recreated my Publisher Key. If you are working alone, this isn't a big process, but if you are part of a team, you will need to distribute the updated key.
Deploying to a PlayStation Vita
In this recipe, we will configure a PS Vita to be used with PSM Studio. Running on a PS Vita device requires a developer license, which you can purchase in the PSM portal.
Getting ready
You will need to have installed the PlayStation Mobile SDK to have the required Vita drivers installed. If you did not install the drivers as part of the install process, under a default install they are available at C:\Program Files (x86)\SCE\PSM\tools\vita\driver. Obviously you will need to have a PS Vita and a USB cable. You will need a project to run on your Vita; load either one of the examples we created earlier or one of the examples from the SDK.
How to do it...
Before you can run on your Vita, you need to install the Development Assistant from the PS Store. Load the PS Store application on your PS Vita device, and then click on the ... button in the bottom-right corner of the screen. Select Download List. Scroll down and select PlayStation Mobile Development Assistant and click on Download. The application will be downloaded and installed.
The PS Mobile Development application icon will now be available on your Vita. If you haven't already, connect your Vita to your PC using the USB cable. If prompted, allow it to install the driver.
On your Vita, run the PS Suite SDK application.
Make sure that your application has been added to the Registered App Key Ring list (see previous recipe for details).
Load up PSM Studio and load a solution to run on your Vita. Now open the Project | PlayStation Suite Device Target | PS Vita menu item. If your PS Vita doesn't show up, select Refresh Device List... and try again. The device will show as off, if the Development Assistant isn't running.
Run your application using either the F5 key or the Run | Start Debugging menu item.
There's more...
Be careful while connecting the USB cable to your Vita. For some unfathomable reason, you can easily put it in upside down! If you aren't getting a connection to your device, be sure to check if your cable is in upside down mode! I thought my Vita was broken the first time I encountered this, as I left it charging, or at least I thought I did. When I came back and it was completely dead, it took a few minutes of head-scratching until I figured out what was wrong.
Manipulating an image dynamically
This recipe will demonstrate using the imaging SDK to resize and crop an image, and then saving that image to the gallery.
Getting ready
This recipe builds on the example created in the prior two recipes. The complete source code is available in Ch01_Example4.
How to do it...
In the Initialize() method, change the code as follows:
Image image = new Image(ImageMode.Rgba,new ImageSize(500,300),new ImageColor(0,0,0,0)); Image resizedImage, croppedImage; image.DrawText("Hello World", new ImageColor(255,255,255,255), new Font(FontAlias.System,96,FontStyle.Italic), new ImagePosition(0,150)); croppedImage = image.Crop (new ImageRect(0,0,250,300)); resizedImage = croppedImage.Resize(new ImageSize(500,300)); _texture = new Texture2D(resizedImage.Size.Width,resizedImage.Size. Height,false,PixelFormat.Rgba); _texture.SetPixels(0,resizedImage.ToBuffer()); resizedImage.Export("My Images","HalfOfHelloWorld.png"); image.Dispose(); resizedImage.Dispose(); croppedImage.Dispose();
How it works...
First, we dynamically generate our image just like we did in the previous recipe. We then crop that image to half its width, by calling the Crop() function and providing an ImageRect variable half the size of the image. Crop returns a new image (it is not destructive to the source image) that we store in croppedImage. We then resize that image back to the original size by calling the Resize() function on croppedImage, with the original size specified as an ImageSize object. Like Crop(), Resize() is not destructive and returns a new image that we store in resizedImage. We then copy the pixels from resizedImage into our texture using SetPixels().
Next, we call Export(), which saves our cropped and resized image in a folder called My Images as a file named HalfOfHelloWorld.png on your device. Finally, we call Dispose() on all three images, to free up the memory they consumed
Now if you run your code, instead of "Hello World", you simply get "Hello".
There's more...
When run on the simulator, export will save the image to your My Pictures folder. Be sure to call Dispose(), or wrap within a using statement all objects that implement IDisposable, or you will quickly run out of memory. Most resources like images and textures require disposal.
Working with the filesystem
This recipe illustrates the various ways you can access the filesystem.
Getting ready
The complete code for this example is available in Ch1_Example5. This example adds the following two new using statements:
using System.Linq;
using System.IO;
How to do it...
Create a new solution and enter the following code replacing the Main() function:
public static void Main (string[] args){ const string DATA = "This is some data"; byte[] persistentData = PersistentMemory.Read(); byte[] restoredData = persistentData.Take(DATA.Length * 2).ToArray(); string restoredString = System.Text.Encoding.Unicode. GetString(restoredData); byte[] stringAsBytes = System.Text.Encoding.Unicode.GetBytes(DATA); for(int i = 0; i < stringAsBytes.Length; i++) persistentData[i] = stringAsBytes[i]; PersistentMemory.Write (persistentData); using(FileStream fs = File.Open("/Documents/Demo.txt",FileMode. OpenOrCreate)){ if(fs.Length == 0) fs.Write(stringAsBytes,0,stringAsBytes.Length); else{ byte[] fileContents = new byte[fs.Length]; fs.Read(fileContents,0,(int)fs.Length); } } }
How it works...
The first part of this sample demonstrates using the PersistentMemory class. It is a statically available class, so you cannot allocate one. Instead you access it using PersistentMemory. Read(). This returns a byte array that you can now modify. We read some data using the LINQ extension Take() method. We multiplied the size by 2 because the string is stored as UNICODE, which requires 2 bytes per character. We then convert those bytes into a Unicode string. Next, we convert our DATA string into a byte array, then write it to persistentData byte by byte in a for loop. Finally we commit our changes to persistentMemory by calling PersistentMemory.Write(), passing in our updated persisitentMemory byte array.
The next part of the recipe demonstrates traditional file access using the standard .NET libraries, in this case File and FileStream. We open a text file in the /Documents folder named Demo.txt, creating it if it doesn't exist. If the file doesn't exist, we write our byte array stringAsBytes to the file. Otherwise, we read the file contents into a new byte array fileContents.
The first time you run this example, PersistentMemory.Read() will contain gibberish, as nothing has been written to it yet. On the second run, it will start with the bytes composing your DATA string.
There's more...
Persistent storage is limited to 64 KB in space. It is meant for quickly storing information, such as configuration settings. It is physically stored on the filesystem in the /save directory in a file named pm.dat.
There are three primary locations for storing files:
/Application: This is where your application files reside, as well as files added with the "Content" build action. These files are read only.
/Documents: This is where you put files that require read and write access.
/Temp: This is where you put temporary files, that can be read and written. These files will be erased when your program exits.
The PlayStation Mobile SDK limits directory structures to at most 5 levels deep, including the filename. Therefore, /documents/1/2/3/myfile.txt is permitted, but / documents/1/2/3/4/myfile.txt is not.
The PersistentMemory classes was deprecated in the 1.0 release of PSM SDK and should no longer be used. Use traditional .NET file methods instead
Handling system events
This recipe covers handling the OnRestored system event.
Getting ready
The complete code for this example is available in Ch01_Example06
How to do it...
Replace Main() with the following code:
public class AppMain { static bool _done = false; public static void Main (string[] args){ SystemEvents.OnRestored += HandleSystemEventsOnRestored; while(!_done) { SystemEvents.CheckEvents(); // Loop until application minimized then restored. } } static void HandleSystemEventsOnRestored (object sender, RestoredEventArgs e) { Console.WriteLine ("System restored, ok to shut down"); _done = true; } }
How it works...
This code starts by wiring an OnRestored event handler to global class SystemEvents. We then loop until the _done bool is set to true. Within our loop we poll SystemEvents. CheckEvents() to see if any events have occurred. If an OnRestored event occurs, our event handler will be fired.
Our event handler HandeSystemEventsOnRestored() simply writes out a message to the console, then sets the _done bool to true, causing our loop to end, and our program to exit.
Run this example, then minimize the simulator or change applications on your device. When you refocus the application, it will fire the OnRestored event, causing your program to exit.
Summary
This Article covers getting the PlayStation Mobile SDK up and running and deployed to various devices (a task of some complexity). It jumps right in, creating basic graphical applications and covers the details and restraints of working on the devices.
Resources for Article :
Further resources on this subject:
- Getting started with Kinect for Windows SDK Programming [Article]
- Getting Started with LiveCode for Mobile [Article]
- Interface Designing for Games in iOS [Article] | https://www.packtpub.com/books/content/getting-started-playstation-mobile | CC-MAIN-2015-14 | refinedweb | 4,880 | 57.67 |
An easy-to-use Pythonic wrapper for the FLIR PySpin Library. Developed by the Kleckner Lab at UC Merced.
Project description
simple_pyspin
A Pythonic class-based wrapper for the FLIR PySpin Library.
More documentation can be found on Github Pages, and the source can be found on Github.
Why?
Why does this even exist, as the PySpin module already exists? Because it's a pain to use, and difficult to wrap your head around basic operations. For example, on some camera manually setting frame rate requires accessing methods by finding nodes, which is quite complicated. This library makes it incredibly simple, and can also auto-document all the features of your specific cameras for easy reference.
Installation
- If you don't already have them, I would recommend installing Numpy and the Python Imaging Library. The easiest way to do this is to install a scientific Python distribution like Anaconda.
- Install Spinnaker and PySpin from FLIR.
- You will likely need to follow several manual steps after the Spinnaker installation to get PySpin (Mac Instructions)
- Install simple_pyspin module:
- Install from PyPi:
pip install simple-pyspin.
- Download source from GitHub and use
setup.py.
Usage
See the examples directory of the source for these examples and more.
Basic Usage
# dead_simple.py from simple_pyspin import Camera with Camera() as cam: # Acquire and initialize Camera cam.start() # Start recording imgs = [cam.get_array() for n in range(10)] # Get 10 frames cam.stop() # Stop recording print(imgs[0].shape, imgs[0].dtype) # Each image is a numpy array!
Note that as long as you open the camera using a
with clause, you don't need to worry about initialization or cleanup of the camera -- the module handles this for you!
Equivalently, you can do this manually; the following code is functionally identical to the above:
from simple_pyspin import Camera cam = Camera() # Acquire Camera cam.init() # Initialize camera cam.start() # Start recording imgs = [cam.get_array() for n in range(10)] # Get 10 frames cam.stop() # Stop recording cam.close() # You should explicitly clean up print(imgs[0].shape, imgs[0].dtype) # Each image is a numpy array!
Changing Camera Settings
Here is a more complicated example, which manual changes a number of settings, and saves a number of images using PIL.
# manual_setup.py from simple_pyspin import Camera from PIL import Image import os with Camera() as cam: # Initialize Camera # Set the area of interest (AOI) to the middle half cam.Width = cam.SensorWidth // 2 cam.Height = cam.SensorHeight // 2 cam.OffsetX = cam.SensorWidth // 4 cam.OffsetY = cam.SensorHeight // 4 # If this is a color camera, get the image in RGB format. if 'Bayer' in cam.PixelFormat: cam.PixelFormat = "RGB8" # To change the frame rate, we need to enable manual control cam.AcquisitionFrameRateAuto = 'Off' cam.AcquisitionFrameRateEnabled = True cam.AcquisitionFrameRate = 20 # To control the exposure settings, we need to turn off auto cam.GainAuto = 'Off' # Set the gain to 20 dB or the maximum of the camera. gain = min(20, cam.get_info('Gain')['max']) print("Setting gain to %.1f dB" % gain) cam.Gain = gain cam.ExposureAuto = 'Off' cam.ExposureTime = 10000 # microseconds # If we want an easily viewable image, turn on gamma correction. # NOTE: for scientific image processing, you probably want to # _disable_ gamma correction! try: cam.GammaEnabled = True cam.Gamma = 2.2 except: print("Failed to change Gamma correction (not avaiable on some cameras).") cam.start() # Start recording imgs = [cam.get_array() for n in range(10)] # Get 10 frames cam.stop() # Stop recording # Make a directory to save some images output_dir = 'test_images' if not os.path.exists(output_dir): os.makedirs(output_dir) print("Saving images to: %s" % output_dir) # Save them # NOTE: images may be very dark or bright, depending on the camera lens and # room conditions! for n, img in enumerate(imgs): Image.fromarray(img).save(os.path.join(output_dir, '%08d.png' %. | https://pypi.org/project/simple-pyspin/ | CC-MAIN-2021-04 | refinedweb | 632 | 61.02 |
Start Lecture #1
I start at 0 Dale, Joyce, and Weems,
Object-Oriented Data Structures Using Java.
It is available at the NYU Bookstore.. The weighting will be approximately 30%*Labs, 30%*Midterm, and 40%*Final .
The following is supposed to work; let's see.
mailx -s "the subject goes here" gottlieb@nyu.edu words go here and go in the msg. The next line causes a file to be placed in the msg (not attached simply copied in) ~r filename .
Good methods for obtaining help include
You labs must be written in Java.
Incomplete
The rules for incompletes and grade changes are set by the school and not the department or individual faculty member.
The rules set by CAS can be found here. department
The university-wide policy is described here.
In 101 our goal was to learn how to write correct programs in Java.
Step 1 in that goal,.
One question will be how to measure the performance. loop over N numbers as shown on the right. Minimum is the same simple idea.
Both of these are essentially optimal: To find the max, we surely need to examine each number so the work done will be proportional to N and the program above is proportional to N.
Homework: Write a Java method that computes the 2nd largest. Hint calculate both the largest and 2nd largest; return the latter..
This second method also works for any k.
Both these methods are correct (the most important criterion) and simple. The trouble is that neither method has optimal performance. For large N, say 10,000,000 and k near N/2, both methods take a long time; whereas a more complicated algorithm is very fast.
Another example is given in section 5.3 where we choose a circular array implementation for queues rather than a simpler array implementation because the former is faster.
In 101, we had objects of various kinds, but basically whenever we
had a great deal of data, it was organized as an array (of
something).
An array is an example of a
data structure.
As the course title suggests, we will learn a number of other data
structures this semester.
Sometimes these data structures will be more complicated than simpler ones you might think of. Their compensating advantage is that they have higher performance.
Also we will learn techniques useful for large programs. Although we will not write any large programs, such programs are crucially important in practice. For example, we will use Java generics and interfaces to help specify the behavior we need to implement.
Client-server systems (now often referred to as
cloud computing are of increasing importance.
The idea is that you work on your client computer with assistance
from other server systems.
We will do some of this.
In particular, we will use the computer i5.nyu.edu as a server.
We need to confirm that everyone has an account on i5.nyu.edu.
Homework: As mentioned previously, those of you with Windows clients, need to get putty and winSCP. They are definitely available on the web at no cost. (The last time I checked, winSCP available through ITS and putty was at).
I will do a demo of this software next class. Please do install it by then so you can verify that it works for you.
macOS users should see how to have their terminal run in plain (ascii) text mode.
Read.
Read.
Read.
We have covered this in 101, but these authors tie the attributes of object orientation to the goals of quality software just mentioned.
Read
This section is mostly a quick review of concepts we covered in 101. In particular, we covered.
Most of you learned Java from Liang's book, but any Java text should be fine. Another possibility is my online class notes from 101.
The book does not make clear that the rules given are for data fields and methods. Visibility modifiers can also be used on classes, but the usage and rules are different.
I have had difficulty deciding how much to present about visibility. The full story is complicated and more than we need, but I don't want to simplify it to the extent of borderline inaccuracy. I will state all the possibilities, but describe only those that I think we will use.
A .java file consists of 1 or
more classes.
These classes are called
top level since they are not inside
any other classes.
Inside a class we can define methods, (nested) classes, and fields The later are often called data fields and sometimes called variables. I prefer to reserve the name variables for those declared inside methods.
class TopLevel1 { public int pubField; private int pvtField; protected int proField; int defField; public class PubNestedClass {} private class PriNestedClass {} protected class ProNestedClass {} class DefNestedClass {} } public class TopLevel2 { public static void main (String[] arg) {} private static void pvtMethod() {} protected static void proMethod() {} static void defMethod() {} }
Top-level classes have two possible visibilities: public and package-private (the default when no visibility keyword is used). Each .java file must contain exactly one top-level public class, which corresponds to the name of the file
Methods, fields, and nested classes each have four possible visibilities: public, private, protected, and package-private (the default).
The two visibilities for top-level classes, plus the four visibilities for each of the three other possibilities give a total of 14 possible visibilities, all of which are illustrated on the right.
Question: What is the filename?
For now we will simplify the situation and write .java files as shown on the right.
// one package statement // import statements public class NameOfClass { // private fields and // public methods }
An object is an instantiation of a class. Each object contains a copy of every instance (i.e., non-static) field in the class. Conceptually, each object also contains a copy of every instance method. (Some optimizations do occur to reduce the number of copies, but we will not be concerned with that.)
In contrast all the objects instantiated from the same class share class (i.e., static) fields and methods.
This is a huge deal in Java. It is needed to understand the behavior of objects and arrays. Unfortunately it.
Start Lecture #2
Remark: If your last name begins with A-K your grader is Arunav Borthakur; L-Z have Prasad Kapde. This determines to whom you email your lab assignments
Remark: Chen has kindly created a wiki page on using WinSCP and Putty. See.
Lab: Lab 1 parts 1 and 2 are assigned and are due 13 September 2012. Explain in class what is required.
In all Java systems, you run a program by invoking the
Java Virtual Machine (aka JVM).
The primitive method to do this, which is the only one I use, is to
execute a program named java.
The argument to java is the name of the class file (without the .class extension) containing the main method. A class file is produced from a Java source file by the Java compiler javac. Each .java file is often called a compilation unit since each one is compiled separately.
If you are using an
Integrated Development Environment
(IDE), you probably click on some buttons somewhere, but the result
is the same: The Java compiler javac is given each .java
file as a compilation unit and produces class files; the JVM
program java is run on the class file containing the main
method.
Inheritance was well covered in 101; here I add just a few comments.
public class D extends B { ... }
biggerthan B objects.
biggerthan the set of C objects
Java (unlike C++) permits only what is called
single inheritance.
That is, although a parent can have several children, a child can
have just one parent (a biologist would call this asexual
reproduction).
Single inheritance is simpler than multiple inheritance.
For one thing, single inheritance implies that the classes form a
tree, i.e., a strict hierarchy.
For example, on the right we see a hierarchy of geometric concepts.
Note that a point
is a geometric object and a rhombus
is a quadrilateral.
Indeed, for every line in the diagram, the lower concept
is a
upper concept.
This so-called ISA relation suggests that the lower concept should
be a class derived from the upper.
Indeed the handout shows classes with exactly these inheritances. The Java programs can be found here.
You might think that Java classes form a forest not a tree since you can write classes that are not derived from any other. One example would be ReferenceVsValueSemantics above. However, this belief is mistaken. Any class definition that does not contain the extends keyword, actually extends the built-in class object. Thus Java classes do indeed form a tree, with object as the root.
(I reordered the material in this section.)
Java permits grouping a number of classes together to for a package, which gives the following advantages.
package packageName;
The syntax of the package statement is trivial as shown on the right. The only detail is that this statement must be the first (nonblank, noncomment) line in the file.
import packageName.ClassName; import packageName.*
To access the contents of another package, you must either
import java.util.Scanner; public class Test { public static void main(String[] arg) { int x; Scanner getInput = new Scanner(System.in); x = getInput.nextInt(); } public class Test { public static void main(String[] arg) { int x; java.util.Scanner getInput = new java.util.Scanner(System.in); x = getInput.nextInt(); } }
For example, recall from 101 the important Scanner class used to read free-form input. This class is found in the package java.util.
To read an int, one creates a Scanner object (I normally call mine getInput) and then invokes the nextInt() method in this object.
The two examples on the right illustrate the first and third procedures mentioned above for accessing a package's contents. (For the second procedure, simply change java.util.Scanner to java.util.*.
Note that both the Scanner class and the nextInt() method have public visibility. How do I know this and where can you go to check up on me?
The key is to go to java.sun.com. This will send you to an Oracle site, but Java is a Sun product; Oracle simply bought Sun. You want Java SE-->documentation-->API
Let's check and see if I was right that Scanner and nextInt() are public.
Homework: How many methods are included in the Scanner class? How many of them are public?
The name of a package constrains where its files are placed in the filesystem. First, assume a package called packageName consisting of just one file ClassName.java (this file defines the public class ClassName). Although not strictly necessary, we will place this .java files in a directory called packageName.
javac packageName/ClassName.java
To compile this file we go to the parent directory of packageName and type the command on the right. (I use the Unix notation, / for directories; Windows uses \.)
Unlike the situation above, most packages have multiple .java files.
javac packageName/*.java
If the package packageName contains many .java files, we place them all in a directory also called packageName and compile them by going to the parent of packageName and executing the command on the right.
Just as the .java files for a package named packageName go in a directory named packageName, the .java files for a package named first.second go in the subdirectory second of a directory named first.
javac first/second/*.java
To compile these .java files, go to the parent of first and type the command on the right
javac first/second/third*.java
Similarly a package named first.second.third would be compiled by the command on the right.
The simplest situation is to leave the generated .class flies in the same directory as the corresponding .java files and execute the java command from the same directory that you executed the javac command, i.e., the parent directory.
I show several examples on the right.
java packageName/ClassName java testPackage/Test java bigPackage/M java first/second/third/M
The examples above assume that there is just one package, we keep the .class files in the source directory, and we only include classes from the Java library. All of these restrictions can be dropped by using the CLASSPATH environment variable.
public class Test { public static void main (String[] args) { C c = new C(); c.x = 1; } } public class C { public int x; }
The basic question is
Where do the compiler and JVM look for .java
and .class files?.
First consider the 2-file program on the right. You can actually compile this with a simple javac Test.java. How does the compiler find the definition of the class C?
The answer is that it looks in all .java files in the current directory. We use CLASSPATH if we want the compiler to look somewhere else.
Next consider the familiar line
include java.util.Scanner;.
How does the compiler (and the JVM) find the definition of
the Scanner class?
Clearly java.util is a big clue, but where do they look
for java.util.
The answer is that they look in the
system jar file
(whatever that is).
We use CLASSPATH if we want it to look somewhere else in
addition.
Many of the Java files used in the book are available on the web (see page 28 of the text for instructions on downloading). I copied the directory tree to /a/dale-datastructures/bookFiles on my laptop.
In the subdirectory ch02/stringLogs we find all the .java files for the package ch02.stringLogs.
One of these files is named LLStringNode.java and contains the definition of the corresponding class. Hopefully the name signifies that this class defines a node for a linked list of strings.
import ch02.stringLogs.LLStringNode; public class DemoCLASSPATH { public static void main (String[] args) { LLStringNode lLSN = new LLStringNode("Thank you CLASSPATH"); System.out.println(lLSN.getInfo()); } }
I then went to directory java-progs not related to /a/dale-datastructures/bookFiles and wrote the simple program on the right.
A naive attempt to compile this with javac DemoCLASSPATH.java fails since it cannot find a the class LLStringNode in the subdirectory ch02/stringLogs (indeed java-progs has no such directory.
export CLASSPATH=/a/dale-datastructures/bookFiles:.
However once CLASSPATH was set correctly, the compilation succeeded. On my (gnu-linux) system the needed command is shown on the right.
Homework: 28. (When just a number is given it refers to the problems at the end of the chapter in the textbook.)
Data structures describe how data is organized.
Some structures give the physical organization, i.e., how the data is stored on the system. For example, is the next item on a list stored in the next higher address, or does the current item give the location explicitly, or is there some other way.
Other structures give the logical organization of the data. For example is the next item always larger than the current item? For another example, as you go through the items from the first, to the next, to the next, ..., to the last, are you accessing them in the order in which they were entered in the data structure?
Well studied in 101.
We will study linked implementations a great deal this semester. For now, we just comment on the simple diagram to the right.
groundsymbol from electrical engineering).
Start Lecture #3
Remark: Chen will have an office hour Wednesdays 5-6pm in CIWW 412.
For these structures, we don't describe how the items are stored, but instead which items can be directly accessed.
The defining characteristic of a stack is that you can access or remove only the remaining item that was most recently inserted. We say it has last-in, first-out (LIFO) semantics. A good real-world example is a stack of dishes, e.g., at the Hayden dining room.
In
Java-speak we say a stack object has three public
methods: top() (which returns the most recently inserted
item remaining on the list), pop() (which removes the
most recently inserted remaining item), and push() (which
inserts its argument on the top of the list).
Many authors define pop() to both return the top element and remove it from the stack. That is, many authors define pop() to be what we would call top();pop().
The defining characteristic of a queue is that you can remove only the remaining item that was least recently inserted. We say it has first-in, first-out (FIFO) semantics. A good example is an orderly line at the bank.
In java-speak, we have enqueue() (at the rear) and dequeue() (from the front). (We might also have accessors front(), and rear().
Homework: Customers at a bank with many tellers form a single queue. Customers at a supermarket with many cashiers form many queues. Which is better and why?
Here the first element is the smallest, each succeeding element is larger (or equal to) its predecessor, and hence the last element is the largest. It is also possible for the elements to be in the reverse order with the largest first and the smallest last.
One natural implementation of a sorted list is an array with the elements in order; another is a linked list, again with the elements in order. We shall learn other structures for sorted lists, some of which provide searching performance much higher than either an array or simple linked list.
The structures we have discussed are one dimensional (except for higher-dimensional arrays). Each element except the first has a unique predecessor, each except the last has a unique successor, and every element can be reached by starting at one end and heading toward the other.
Trees, for example the one on the right, are different. There is no single successor; pictures of trees invariable are drawn in two dimensions, not just one.
Note that there is exactly one path between any two nodes.
Trees are a special case of graphs. In the latter, we drop the requirement of exactly one path between any two nodes. Some nodes may be disconnected from each other and others may have multiple paths between them.
A specific method for organization, either logically or physically.
A references is a pointer to (or the address of) an object; they are typically drawn as arrows.
We covered this topic is section 1.3, but it is such a huge deal in Java that we will cover it again here (using the same example). Reference semantics determine the behavior of objects and arrays. Unfortunately these semantics.
Continuing with the last example, we note that c1 and c2 refer to the same object. They are sometimes called aliases. As the example illustrated, aliases can be confusing; it is good to avoid them if possible.
What about the top ellipse (i.e., object) in the previous diagram for which there is no longer a reference? Since it cannot be named, it is just wasted space that the programmer cannot reclaim. The technical term is that the object is garbage. However, there is no need for programmer action or worry, the JVM detects garbage and collects it automatically.
The technical terminology is that Java has a built-in garbage collector.
Thus Java, like most modern programming languages supports the run-time allocation and deallocation of memory space, the former is via new, the latter is performed automatically. We say that Java has dynamic memory management.
// Same class C as above public class Example { public static void main (String[] args) { C c1 = new C(1); C c2 = new C(2); C c3 = c1; for (int i=0; i<1000; i++) { c3 = c2; c3 = c1; } } }
Execute the code on the right in class. Note that there are two objects (one with x==1 and one with x==2) and three references (the ones in c1, c2, and c3).
As execution proceeds the number of references to the object with x==1 changes from 1 to 2 to 1 to 2 ... . The same pattern occurs for the references to the other object.
Homework: Can you
write a program where the number of references to a fixed object
changes from 1 to 2 to 3 to 2 to 3 to 2 to 3 ... ?
Can you write a program where the number of references to a fixed object changes from 1 to 0 to 1 to 0 to 1 ... ?
In Java, when you write r1==r2, where the r's are variables referring to objects, the references are compared, not the contents of the objects. Thus r1==r2 evaluates to true if and only if r1 and r2 are aliases.
We have seen equals() methods in 101 (and will see them again this semester). Some equals() methods, such as the one in the String class, do compare the contents of the referred to objects. Others, for example the one in the object class, act like == and compare the references.
First we need some, unfortunately not standardized, terminology. Assume in your algebra class the teacher defined a function f(x)=x+5 and then invoked it via f(12). What would she call x and what would she call 12. As mentioned above, usage differs.
I call x (the item in the callee's definition) a parameter and I call 12 (the item in the caller's invocation) an argument. I believe our text does as well.
Others refer to the item in the callee as the
formal parameter and the item in the caller as the
actual parameter.
Still others use
argument and
parameter
interchangeably.
After settling on terminology, we need to understand Java's parameter passing semantics. Java always uses call-by-value semantics. This means.
public class DemoCBV { public static void main (String[] args) { int x = 1; CBV cBV = new CBV(1); System.out.printf("x=%d cBV.x=%d\n", x, cBV.x); setXToTen(x, cBV); System.out.printf("x=%d cBV.x=%d\n", x, cBV.x); } public static void setXToTen(int x, CBV cBV) { x = 10; cBV.x = 10; } } public class CBV { public int x; public CBV (int x) { this.x = x; } }
Be careful when the argument is a reference. Call-by-value still applies to the reference but don't mistakenly apply it to the object referred to. For example, be sure you understand the example on the right.
Well covered in 101.
There is nothing new to say: an array of objects is an array of
objects.
You must remember that arrays are references and objects are
references, so there can be
two layers of arrows.
Also remember that you will need a new to create the
array and another new to create each
object.
The diagram on the right shows the result of executing
cBV = new CBV(7); CBV[] arrCBV = new CBV[5]; arrCBV[0] = cBV; arrCBV[2] = new CBV(4);
Note that only two of the five array slots have references to objects; the other three are null.
Lab: Lab 1 part 3 is assigned and is due in 7 days.
As discussed in 101, Java does not, strictly speaking, have 2-dimensional arrays (or 3D, etc). It has only 1D arrays. However each entry in an array can itself be an array
On the right we see a two dimensional array M with two rows and three columns that can be produced by executing
int[][] M; M = new int [2][3];
Note that M, as well as each M[i] is a reference. The latter are references to int's; whereas, the former is a reference to an array of int's.
2d-arrays such as M above in which all rows have the same length are often called matrices or rectangular arrays and are quite important.
Java however does support so-called
ragged arrays such as
R shown on the right.
That example can be produced by executing
int [][] R; R = new int [2][]; R[0] = new int [3]; R[1] = new int [1];
Homework: Write a Java program that creates a 400 by 500 matrix with entry i,j equal to i*j.
The idea is to approximate the time required to execute an algorithm (or a program implementing the algorithm) independent of the computer language (or the compiler / computer). Most importantly we want to understand how this time grows as the problem size grows.
For example, suppose you had an unordered list of N names and wanted to search for a name that happens not to be on the list.
You would have to test each of the names. Without knowing more, it is not possible to give the exact time required. It could be 3N+4 seconds or 15n+300 milliseconds, or many other possibilities.
But it cannot be 22 seconds or even 22log(N) seconds. You just can't do it that fast (for large N).
If we look at a specific algorithm, say the obvious check one entry at a time, we can see the time is not 5N2+2N+5 milliseconds. It isn't that slow (for large N).
Indeed that obvious algorithm takes AN+B seconds, we just don't know A and B.
We will crudely approximate the above analysis by saying the algorithm has (time) complexity (or takes time) O(N).
That last statement is really sloppy. We just did three analyses. First we found that the complexity was greater than 22log(N), and then we found that the complexity was less than 5N2+2N+5, and finally we asserted the complexity was AN+B. The big-Oh notation strictly speaking covers only the second (upper-bound) analysis; but is often used, e.g., by the authors, to cover all three.
The rest of this optional section is from a previous incarnation of 102, using a text by Weiss.
We want to capture the concept of comparing function growth where
we ignore additive and multiplicative constants.
For example we want to consider 4N2-500N+1 to
be
equivalent).
It is difficult to decide how much to emphasize algorithmic analysis, a rather mathematical subject. On the one hand
On the other hand
As a compromise, we will cover it, but only lightly (as does our text).
For the last few years we used a different text, with a more mathematical treatment. I have left that material at the end of these notes, but, naturally, it is not an official part of this semester's courses.
As mentioned above we will be using the
big-O
(or
big-Oh) notation to indicate we are giving an
approximation valid for large N.
(I should mention that the O above is really the Greek Omicron.)
We will be claiming that, if N is large (enough), 9N30 is insignificant when compared to 2N.
Most calculators cannot handle really large numbers, which makes the above hard to demo.
import java.math.BigInteger; public class DemoBigInteger { public static void main (String[] args) { System.out.println( new BigInteger("5").multiply( new BigInteger("2").pow(1000))); } }
Fortunately the Java library has a class BigInteger that allows arbitrarily large integers, but it is a little awkward to use. To print the exact result for 5*21000 you would write a program something like the one shown on the right.
To spare you the anxiety of wondering what is the actual answer, here it is (I added the line breaks manually).
53575430359313366047421252453000090528070240585276680372187519418517552556246806 12465991894078479290637973364587765734125935726428461570217992288787349287401967 28388741211549271053730253118557093897709107652323749179097063369938377958277197 30385314572855982388432710838302149158263121934186028340346880
Even more fortunately, my text editor has a built in infinite precision calculator so we can try out various examples. Note that ^ is used for exponentiation, B for logarithm (to any base), and the operator is placed after the operands, not in between.
Do the above example using emacs calc.
The following functions are ordered from smaller to largerN-3 N-1 N-1/2 N0 N1/3 N1/2 N1 N3/2 N2 N3 ... N10 ... N100
Three questions that remain (among many others) are
To answer the first question we will (somewhat informally) divide one function by the next. If the quotient tends to zero when N gets large, the second is significantly larger that the first. If the quotient tends to infinity when N gets large, the second is significantly smaller than the first.
Hence in the above list of powers of N, each entry is significantly larger than the preceding. Indeed, any change in exponent is significant.
The answer to the second question is that log(N) comes after N0 and before NP for every fixed positive P. We have not proved this.
The answer to the third question is that 2N comes after NP for every fixed P. (The 2 is not special. For every fixed Q>1, QN comes after every fixed NP.) Again, we have not proved this.
Do some examples on the board.
Read. The idea is to consider two methods to add 1+2+3+4+...+N
These have different big-Oh values.
So a better algorithm has better (i.e., smaller) complexity.
Imagine first that you want to calculate (0.3)100. The obvious solution requires 99 operations.
In general for a fixed b≠0, raising bN using the natural algorithm requires N-1=O(N) operations.
I describe the algorithm for the special case of .3100 but it works in general for bN. The basic idea is to write 100 in binary and only use those powers. On the right is an illustration.
1 2 4 8 16 32 64 128
0 0 1 0 0 1 1 0
.3 .32 .34 .38 .316 .332 .364
.32 × .332 × .364
Since there were just 4 large steps, each of which has complexity O(log(N)), so does the entire algorithm.
Homework: The example above used N=100. The natural algorithm would do 99 multiplications, the better algorithm does 8. Assume N≤1,000,000. What is the maximum number of multiplications that the natural algorithm would perform? What is the maximum number of multiplications that the better algorithm would perform?
Start Lecture #4
Assume the phone book has N entries.
If you are lucky, the first entry succeeds, this takes O(1) time.
If you are unlucky, you need the last entry or, even worse, no entry works. This takes O(N) time.
Assuming the entry is there, on average it will be in the middle. This also takes O(N) time.
From a big-Oh viewpoint, the best case is much better than the average, but the worst case is the same as the average.
Lab: Lab 1 part 4 is assigned and is due in 7 days.
The above is kinda-sorta OK. When we do binary search for real will get the details right. In particular we will worry about the case where the sought for item is not present.
This algorithm is a big improvement. The best case is still O(1), but the worst and average cases are O(log(N)).
BUT binary search requires that the list is sorted. So either we need to learn how to sort (and figure out its complexity) or learn how to add items to a sorted list while keeping it sorted (and figure out how much this costs.
This are not trivial questions; we will devote real effort on their solutions.
Read
public class Quadrilateral extends GeometricObject { ... public Quadrilateral (Point p1, Point p2, Point p3, Point P4) public double area() {...} }
Definition: An Abstract Data Type is a data type whose properties are specified but not their implementations. For example, we know from the abstract specification on the right that a Quadrilateral is a Geometric Object, that it is determined by 4 points, and that its area can be determined with no additional information.
The idea is that the implementor of a modules does not reveal all the details to the user. This has advantages for both sides.
In 201 you will learn how integers are stored on modern computers (twos compliment), how they were stored on the CDC 6600 (ones complement), and perhaps packed decimal (one of the ways they are stored on IBM mainframes). For many applications, however, the implementations are unimportant. All that is needed is that the values are mathematical integers.
For any of the implementations, 3*7=21, x+(y+z)=(x+y)+z (ignoring overflows), etc. That is, to write many integer-based programs we need just the logical properties of integers and not their implementation. Separating the properties from the implementation is called data abstraction.
Consider the BigDecimal class in the Java library that we mentioned previously (it includes unbounded integers). There are three perspectives or levels at which we can study this library.
Preconditions are requirements placed on the user of a method in order to ensure that the method behaves properly. A precondition for ordinary integer divide is that the divisor is not zero.
A postcondition is a requirement on the implementation. If the preconditions are satisfied, then upon method return the postcondition will be satisfied.
This is Java's way of specifying an ADT. An interface is a class with two important restrictions.
The implied keywords public static final and public abstract can be (and typically are) omitted.
A method without a body is specified at the user level, it tells you what arguments you must supply and the type of the value returned. It does not tell you how any properties of the return value or any side effects of the method (e.g., values printed).
Each interface used must be implemented by one or more real classes that have non-abstract versions of all the methods.
The next two sections give examples of interfaces and their implementing classes. You can also read the FigureGeometry interface in this section.
As a warm up for the book's Stringlog interface, I present an ADT and two implementations of the trivial operation of squaring an integer. I even threw in a package. All in all it is way overblown. The purpose of this section is to illustrates the Java concepts in an example where the actual substance is trivial and the concepts are essentially naked.
There are four .java files involved as shown on the right and listed below. The first three constitute the squaring package and are placed in a directory with the same name (standard for packages).
package squaring; public interface SquaringInterface { int getSquare(); } package squaring; public class SimpleSquaring implements SquaringInterface { private int x; public SimpleSquaring(int x) { this.x = x; } public int getSquare() { return x*x; } } package squaring; public class FancySquaring implements SquaringInterface { private int x; public FancySquaring(int x) { this.x = x; } public int getSquare() { int y = x + 55; return (x+y)*(x-y)+(y*y); } } import squaring.*; public class DemoSquaring { public static void main(String[] args) { SquaringInterface x1 = new SimpleSquaring(5); SquaringInterface x2 = new FancySquaring(6); System.out.printf("(x1.x)*(x1.x)=%d (x2.x)(x2.x)=%d\n", x1.getSquare(), x2.getSquare()); } }
The first file is the ADT. The only operation supported is to compute and return the square of the integer field of the class. Note that the (non-constant) data field is not present in the ADT and the (abstract) operation has no body.
The second file is the natural implementation, the square is computed by multiplying. Included is a standard constructor to create the object and set the field.
The third file computes the square in a silly way (recall that (x+y)*(x-y)=x*x-y*y). The key point is that from a client's view, the two implementations are equivalent (ignoring performance).
The fourth file is probably the most interesting. It is located in the parent directory. Both variables have declared type SquaringInterface. However, they have actual types SimpleSquaring and FancySquaring respectively.
A Java interface is not a real class so no object can have actual type SquaringInterface (only a real class can follow new). Since the getSquare() in each real class overrides (not overloads) the one in the interface, the actual type is used to choose which one to invoke. Hence x1.getSquare() invokes the getSquare() in SimpleSquaring; whereas x2.getSquare() invokes the getSquare() is FancySquaring().
UML is a standardize way of
summarizing classes and
interfaces.
For example, the 3 classes/interfaces for in the squaring
package would be written as shown on the right.
The commands in this section are run from the parent directory of squaring. Note that the name of this parent is not important. What is important is that the name of the squaring must agree with the package name.
javac squaring/*.java javac DemoSquaring.java java DemoSquaring
It would be perfectly fine to execute the three lines on the right, first compiling the package and then compiling and running the demo.
However, the first line is not necessary. The import statement in DemoSquaring.java tells the compiler that all the classes in the squaring package are needed. As a result the compiler looks in subdirectory squaring and compiles all the classes.
Homework: 9, 10.
In contrast to the above, we now consider an example of a useful package.
The book's stringLogs package gives the specification and two implementations of an ADT for keeping logs of strings. A log has two main operations, you can insert a string into the string and ask if a given string is already present in the log.
Homework: If you haven't already done so, download the book's programs onto your computer. It can be found at.
Unzip the file and you will have a directory hierarchy starting at XXX/bookFiles, where XXX is the absolute name (i.e. starting with / or \) of the directory at which you executed the unpack. Then set CLASSPATH via
As mention previously much of the book's code can be downloaded onto your system. In my case I put it in the directory /a/dale-dataStructures/bookFiles. Once again the name of this directory is not important, but the names of all subdirectories and files within must be kept as is to agree with the usage in the programs
import ch02.stringLogs.* public class DemoStringLogs { }
To prepare for the serious work to follow I went to a scratch directory and compiled the trial stub for a stringLog demo shown on the right. The compilation failed complaining that there is no ch02 since DemoStringLogs.java is not in the parent directory of ch02.
Since I want to keep my code separate from the book's, I do not want my demo in /a/dale-dataStructures/BookFiles. Instead I need to set CLASSPATH.
export CLASSPATH=/a/dale-dataStructures/bookFiles:.
The command on the right is appropriate for my gnu/linux system and (I believe) would be the same on MacOS. Windows users should see the book. This will be demoed in the recitation.
Now javac DemoStringLogs.java compiles as expected.
StringLog(String name);
Since a user might have several logs in their program, it is useful for each log to have a name. So we will want a constructor something like that on the right.
For some implementations there is a maximum number of entries possible in the log. (We will give two implementations, one with and one without this limit.)
StringLog(String name, int maxEntries);
If we have a limit, we might want the user to specify its value with a constructor like the one on the right.
nicely formattedversion of the log.
Here is the code downloaded from the text web site. One goal of an interface is that a client who reads the interface can successfully use the package.
That is an ambitious goal; normally more documentation is needed.
How about the questions I raised in the previous section?
import ch02.stringLogs.*; public class DemoStringLogs { public static void main (String[] args) { StringLogInterface demo1; demo1 = new ArrayStringLog ("Demo #1"); demo1.insert("entry 1"); demo1.insert("entry 1"); // ?? System.out.println ("The contains() " + "method is case " + (demo1.contains("Entry 1") ? "in" : "") + "sensitive."); System.out.println(demo1); } } The contains() method is case insensitive. Log: Demo #1 1. entry 1 2. entry 1
On the right we have added some actual code to the demo stub above. As is often the case we used test cases to find out what the implementation actually does. In particular, by compiling (javac) and running (java) DemoStringLogs we learn.
conditional expression(borrowed from the C language).
nicely formattedoutput of the toString() method.
Homework: 15.
Homework: Recall that a stringlog can contain multiple copies of the same string. Describe another method that would be useful if multiple strings do exist.
Start Lecture #5
Now it is time to get to work and implement StringLog.
package ch02.stringLogs; public class ArrayStringLog implements StringLogInterface { ... }
In this section we use a simple array based technique in which a StringLog is basically an array of strings. We call this class ArrayStringLog to emphasize that it is array based and to distinguish it from the linked-list-based implementation later in the chapter.
private String[] log; private int lastIndex = -1; private String name;
Each StringLog object will contain the three instance fields on the right: log is the basic data structure, an array of strings with each array entry containing one log entry. name is the name of the log and lastIndex is is the last index (i.e., largest) into which an item has been placed.
The book uses protected (not private) visibility. For simplicity I will keep to the principal that fields are private and methods public until we need something else.
public ArrayStringLog(String name, int maxSize) { this.name = name; log = new String[maxSize]; } public ArrayStringLog(String name) { super(name, 100); // 100 arbitrary }
We must have a constructor
Why? That is, why isn't the default constructor adequate?
Answer: Look at the fields, we need to set name and create the actual array.
Clearly the user must supply the name, the size of the array can either be user-supplied or set to a default. This gives rise to the two constructors on the right.
Although the constructor executes only two Java statements, its complexity is O(N) (not simply O(1). This is because each string in the array is automatically initialized to the empty string. You can see this if you read the String constructor.
Both constructors have the same name, but their signatures (name plus parameter types) are different so Java can distinguish them.
public void insert (String s) { log[++lastIndex] = s; }
This mutator executes just one simple statement so is O(1). Inserting an element into the log is trivial because.
public void clear() { for(int i=0; i<=lastIndex; i++) log(i) = null; lastIndex = -1; }
To empty a log we just need to reset lastIndex.
Why?
If so, why the loop?
public boolean isFull() { return lastIndex == log.length-1; } public String size() { return lastIndex+1; } public String getName() { return name; }
The isFull() accessor is trivial (O(1)), but easy to get wrong by forgetting the -1. Just remember that in this implementation the index stored is the last one used not the next one to use and all arrays start at index 0.
For the same reason size() is lastIndex+1. It is also clearly O(1)
The accessor getName() illustrates why accessor methods
are sometimes called getters.
So that users cannot alter fields
behind the implementor's back, the fields are normally
private and the implementor supplies a getter.
This practice essentially gives the user read-only access to the
fields.
public boolean contains (String str) { for (int i=0; i<=lastIndex; i++) if (str.equalsIgnoreCase(log(i)) return true; return false; }
The contains() method loops through the log looking for the given string. Fortunately, the String class includes an equalsIgnoreCase() so case insensitive searching is no extra effort.
Since the program loops through all N entries it must take time that grows with N. Also each execution of equalsIgnoreCase() can take time that grows with the length of the entry. So the complexity is more complicated and not just O(1) or O(N)
public String toString() { String ans = "Log: " + name + "\n\n"; for (int i=0; i<=lastIndex; i++) ans = ans + (i+1) + ". " + log[i] + "\n"; return ans; }
The toString() accessor is easy but tedious.
It's specification is to return a
nicely formatted version of
the log.
We need to produce the name of the log and each of its entries.
Different programmers would often produce different programs since
what is
nicely formatted for one, might not be nicely
formatted for another.
The code on the right (essentially straight from the book) is
one reasonable implementation.
With such a simple implementation, the bugs should be few and shallow (i.e., easy to find). Also we see that the methods are all fast except for contains() and toString(). All in all it looks pretty good, but ...
Conclusion: We need to learn about linked lists.
Homework: 20, 21.
Read.
As noted in section 1.5, arrays are accessed via an index, a value that is not stored with the array. For a linked representation, each entry (except the last) contains a reference or pointer to the next entry. The last entry contains a special reference, null.
Before we can construct a linked version of a stringlog, we need to define a node, one of the horizontal boxes (composed of two squares) on the right.
The first square Data is application dependent.
For a stringlog, it would be a string, but in general it could be
arbitrarily complex.
However, it need not be arbitrarily complex.
Why?
The Next entry characterizes a linked list; it is a pointer to another node. Note that I am not saying one Node contains another Node, rather that one node contains a pointer to (or a reference to) another node.
As an analogy consider a
treasure hunt game where you are
given an initial clue, a location (e.g., on top of the basement TV).
At this location, you find another clue, ... , until the last clue
points you at the final target.
It is not true that the first clue contains the second, just that the first clue points to the second.
public class LLStringNode { private String info; private LLStringNode link; }
Despite what was just said, the Java code on the right makes it
look as if a node does contain another node.
This confusion is caused by our friend
reference semantics.
Since LLStringNode is a class (and not a
primitive type), a variable of that type, such as link
shown on the right, is a reference, i.e., a pointer
(link corresponds to the Next box above;
info corresponds to Data).
The previous paragraph is important. It is a key to understanding linked data structures. Be sure you understand it.
public LLStringNode(String info) { this.info = info; link = null; }
The LLStringNode constructor simply initializes the two fields. We set link=null to indicate that this node does not have a successor.
Forgive me for harping so often on the same point, but please be sure you understand why the constructor above, when invoked via the Java statement
node = new LLStringNode("test");
gives rises to the situation depicted on the near right and not the situation depicted on the far right.
Recall from 101 that all references are the same size. My house in the suburbs is much bigger than the apartment I had in Washington Square Village, but their addresses are (about) the same size.
Now let's consider a slightly larger example, 3 nodes. We execute the Java statements
node1 = LLStringNode("test1"); node2 = LLStringNode("test2"); node3 = LLStringNode("test3"); node3.setLink(node2); node2.setLink(node1);
setLink() is the usual mutator that sets
the link field of a node.
Similarly we define setInfo(), getLink(), and getInfo().
Homework: 41, 42.
Remark: In 2012-12 fall, this was assigned next lecture.
From the diagram on the right, which we have seen twice before, the Java code for simple linked list operations is quite easy.
The usual terminology is that you
traverse a
list,
visiting each node in order of its occurrence on the
list.
We need to be given a reference to the start of the list (Head in
the diagram) and need an algorithm to know when we have reached the
end of the list (the link component is null).
As the traversal proceeds each node is
visited.
The visit program is unaware of the list; it processes the Data
components only (called info in the code).
public static void traverse(LLStringNode node) { while (node != null) { visit(node.getInfo()); node = node.getLink(); } }
Note that this works fine if the argument is null, signifying a list of length zero (i.e., an empty list).
Note also that you can traverse() a list starting at any node.
The bottom row of the diagram show the desired result of inserting an node after the first node. (The middle row shows deletion.) Two references are added and one (in red) is removed (actually replaced).
The key point is that to insert a node you need the red reference as well as a reference to the new node. In the picture the red reference is the Next field of a node. Another possibility is that it is an external reference to the first node (e.g. Head in the diagram). A third possibility is that the red reference is the null in the link field of the last node. Yet a fourth possibility is that the list is currently empty and the red reference is a null in Head.
However in all these cases the same two operations are needed (in this order).
We will see the Java code shortly.
Mosts list support deletion. However our stringlog example does not, perhaps because logs normally do not (or perhaps because it is awkward for an array implementation).
The middle row in the diagram illustrates deletion for (singly) linked lists. Again there are several possible cases (but the list cannot be empty) and again there is one procedure that works for all cases.
You are given the red reference, which points to the node to be deleted and you set it to the reference contained in the next field of the node to which it was originally pointing.
(For safety, you might want to set the original next field to null).
General lists support traversal as well as arbitrary insertions and deletions. For stacks, queues, and stringlogs only a subset of the operations are supported as shown in the following table. The question marks will be explaned in the next section.
package ch02.stringLogs; public class LinkedStringLog implements StringLogInterface { ... }
This new class LinkedStringLog implements the same ADT as did ArrayStringLog and hence its header line looks almost the same.
private LLStringNode log; private String name;
We again have a name for each stringlog, but the first field looks
weird.
Why do we have a single node associated with each log?
It seems that all questions have the same answer:
reference semantics.
An LLStringNode is not a node but a reference or pointer to a node. Referring to the pictures in the previous section, the log field corresponds to head in the picture and not to one of the horizontal boxes containing data and next components. If the declaration said LLStringNode log new LLStringNode(...), then log would still not be a horizontal box but would point to one. As written the declaration yields an uninitialized data field.
public LinkedStringLog(String name) { this.name = name; log = null; }
An advantage of linked over array based implementations is that there is no need to specify (or have a default for) the maximum size. The linked structure grows as needed. This observation explains why there is no size parameter in the constructor.
As far as I can tell the log=null; statement could have be omitted if the initialization was specified in the declaration.
There are many names involved so a detailed picture may well prove helpful. Note that the rounded boxes (let's hope apple doesn't have a patent on this as well) are actual objects; whereas references are drawn as rectangular boxes. There are no primitive types in the picture.
Note also that all the references are the same size; but not all the objects. The names next to (not inside) an object give the type (i.e., class) of the object. To prevent clutter I did not write String next to the string objects, believing that the "" makes the type clear.
The first frame shows the result of executing
LinkedStringLog lsl = new LinkedStringLog("StrLog1");
Let's go over this first frame and see that we understand every detail in it.
The other two frames show the result after executing
lst.insert ("Node1"); lst.insert ("Node2");
We will discuss them in a few minutes. First, we will introduce insert() with our familiar, much less detailed, picture and present the Java commands that do the work.
Note that the size of a LinkedStringLog and of an LLStringNode look the same in the diagram because they both contain two fields, each of which is a reference (and all references are the same size). This is just a coincidence. Some objects contain more references than do others; some objects contain values of primitive types; and we have not shown the methods associated with types.
An interesting question arises here that often occurs.
A liberal interpretation of the word
log permits a more
efficient implementation than would be possible for a stricter
interpretation.
Specifically does the term log imply that new entries are inserted
at the end of the log?
I think of logs as structures that are append only, but that was never stated in the ADT. For an array-based implementation, insertion at the end is definitely easier, but for linked, insertion at the beginning is easier.
However, the idea of a beginning and an end really doesn't apply to the log. Instead, the beginning and end are defined by the linked implementation. As far as the log is concerned, we can call either side of the picture the beginning.
The bottom row of the picture on the right shows the result of inserting a new element after the first existing element. For stringlogs we want to insert at the beginning of the linked list, so the red reference is the value of Head in the picture or log in the Java code.
public void insert(String element) { LLStringNode node = new LLStringNOde(element); node.setLink(log); log = node; }
The code for insert() is very short, but does deserve
study.
The first point to make is that we are inserting at the beginning of
the linked list so we need a pointer to
the
node before the first node.
The stringlog itself serves as a surrogate for this
pre-first
node.
Let's study the code using the detailed picture in the
An Example section above.
public void clear() { log = null; }
The clear() method simply sets the log back to initial state, with the node pointer null.
Start Lecture #6
Remarks: I added a
uses arrow to the
diagram in section 2.B.
Redo insert using the new detailed diagram.
Homework: 41, 42.
Remark: This homework should have been assigned last lecture.
Lab: 2 assigned. It is due 2 October 2012 and includes an honors supplement.
public boolean isFull() { return false; }
With a linked implementation, no list can be full.
Recall that the user may not know the implementation chosen or may wish to try both linked- and array- based stringlogs. Hence we supply isFull() even though it may never be used and will always return false.
public String getName() { return name; }
getName() is identical for both the linked- and array-based implementations.
public int size() { int count = 0; LLStringNode node = log; while (node != null) { count ++; node = node.getLink(); } return count; }
The size() method is harder for this linked representation than for out array-based implementation since we do not keep an internal record of the size and must traverse the log as shown on the right
An alternate implementation would be to maintain a count field and have insert() increment count by 1 each time.
One might think that the alternate implementation is better for the following reason. Currently insert() is O(1) and size() is O(N). For the alternative implementation both are O(1). However, it is not that simple, the number of items that size() must count is the number of inserts() that have been done, so there could be N insert()'s for one size().
A proper analysis is more subtle.
public String toString() { String ans = "Log: " + name + "\n\n"; int count = 0; for (LLStringNode node=log; node!=null; node=node.getLink()) ans = ans + (++count) + ". " + node.getInfo() + "\n"; return ans; }
The essence of toString() is the same as for the array-based implementation. However, the loop control is different. The controlling variable is a reference, it is advanced by getLink() and termination is a test for null.
public boolean contains(String str) { for (LLStringNode node=log; node!=null; node=node.getLink()) if (str.equalsIgnoreCase(node.getInfo())) return true; return false; }
Again the essence is the same as for the array-based implementation, but the loop control is different. Note that contains() and toString() have the same loop control. Indeed, advancing by following the link reference until it is null is quite common for any kind of linked list.
The while version of this loop control was used in size().
Homework: 44, 47, 48.
Read
Read
A group is developing a software system that is comprised of several modules, each with a lead developer. They collect the error messages that are generated during each of their daily builds. Then they wish to know, for specified error messages, which modules encountered these errors.
I wrote a CodeModule class that contains the data and methods for one code module, including a stringlog of its problem reports. This class contains
This is not a great example since stringlogs are not a perfect fit. I would think that you would want to give a key word such as documentation and find matches for documentation missing and inadequate documentation . However, stringlogs only check for (case-insensitive) complete matches.
The program reads three text files.
Let's look at the UML and sketch out how the code should be constructed. Hand out the UML for stringlogs. The demo class could be written many ways, but we should pretty much all agree on CodeModule.java.
The Java programs, as well as the data files, can be found here.
Note that program is a package named codeQuality. Hence it must live in a directory also named codeQuality. To compile and run the program, I would be in the parent directory and execute.
export CLASSPATH=/a/dale-dataStructures/bookFiles:. javac codeQuality/DemoCodeQuality.java java codeQuality/DemoCodeQuality
You would do the same but the replace /a/dale-dataStructures/BookFiles by wherever you downloaded the book's packages.
It is important to distinguish the user's and implementers view of data structures. The user just needs to understand how to use the structure; whereas, the implementer must write the actual code. Java has facilities (classes/interfaces) that make this explicit.
Start Lecture #7
We will now learn our first general-purpose data structure, taking a side trip to review some more Java.
Definition: A stack is a data structure from which one can remove or retrieve only the element most recently inserted.
This requirement that removals are restricted to the most recent insertion implies that stacks have the well-known LIFO (last-in, first-out) property.
In accordance with the definition the only methods defined for stacks are push(), which inserts an element, pop(), which removes the most recently pushed element still on the stack, and top(), which retrieves (but does not remove) the most recently pushed element still on the stack.
An alternate approach is to have pop() retrieve as well as remove the element.
Stacks are a commonly used structure, especially when working with data that can be nested. For example consider evaluating the following postfix expression (or its infix equivalent immediately below).
22 3 + 8 * 2 3 4 * - - ((22 + 3) * 8) - (2 - 3 * 4))
A general solution for infix expressions would be challenging for us, but for postfix it is easy!
Homework: 1, 2
In Java a collection represents a group of objects, which are called the collections's elements. A collection is a very general concept that can be refined in several ways. We shall see several such refinements.
For example, some collections permit duplicates; whereas others do not. Some collections, for example, stacks and queues, restrict where insertions and deletions can occur. In contrast other collections are general lists, which support efficient insertion/deletion at arbitrary points.
Last semester I presented a sketch of these concepts as an optional topic. You might wish to read it here.
Our ArrayStringLog class supports a collection of Strings. It would be easy, but tedious, to produce a new class called ArrayIntegerLog that supports a collection of Integers. It would then again be easy, but now annoying, to produce a third class ArrayCircleLog, and then ArrayRectangleLog, and then ... .
If we needed logs of Strings, and logs of Circles, and logs of Integers, and logs of Rectangles, we could cut the ArrayStringlog class, paste it four times and do some global replacements to produce the four needed classes. But there must be a better way!
In addition this procedure would not work for a single heterogeneous log that is to contain Strings, Circles, Integers, and Rectangles.
public class T { ... } public class S extends T { ... } public class Main { public static void main(String[] args) { T t; S s; ... t = s; } }
Recall from 101 that a variable of type T can be assigned a value from any class S that is a subtype of T.
For example, consider three files T.java, S.java, and Main.java as shown on the right. We know that the final assignment statement t=s; is legal; whereas, the reverse assignment s=t; may be invalid;
When applied to our ArrayStringLog example, we see that, if we developed an ArrayObjectLog class (each instance being a log of Java objects) and constructed objLog as an ArrayObjectLog, then objLog could contain three Strings, or it could contain two Circles, or it could contain four Doubles, or it could contain all 9 of these objects at the same time.
For this heterogeneous example where a single log is to contain items of many different types, ArrayObjectLog is perfect.
As we just showed, an ArrayObjectLog can be used for either homogeneous logs (of any type) or for heterogeneous logs. I asserted it is perfect for the latter, but (suspiciously?) did not comment on its desirability for the former.
To use ArrayObjLog as the illustrative example, I must extend it a little. Recall that all these log classes have an insert() method that adds an item to the log.. Pretend that we have augmented the classes to include a retrieve() method that returns some item in the log (ignore the possibility that the log might be empty). So the ArrayStringLog method retrieve() returns a String, the ArrayIntegerLog method retrieve() returns an Integer, the ArrayObjectLog method retrieve() returns an Object, etc.
Recall the setting. We wish to obviate the need for all these log classes except for ObjectLog, which should be capable of substituting for any of them. The code on the right uses an ObjectLog to substitute for an IntegerLog.
ArrayObjectLog integerLog = new ArrayObjectLog("Perfect?"); Integer i1=5, i2; ... integerLog.insert(i1); // always works i2 = integerLog.retrieve(); // compile error i2 = (Integer)integerLog.retrieve(); // risky Object o = integerLog.retrieve(); if (o instanceof Integer) i2 = (Integer)o; // safe else // What goes here? // Answer: A runtime error msg // or a Java exception (see below).
Java does not know that this log will contain only Integers so a naked retrieve() will not compile.
The downcast will work providing we in fact insert() only Integers in the log. If we erroneously insert something else, retrieve()d will generate a runtime error that the user may well have trouble understanding, especially if they do not have the source code.
Using instanceof does permit us to generate a (hopefully) informative error message, and is probably the best we can do. However, when we previously used a real ArrayIntegerLog no such runtime error could occur, instead any erroneous insert() of a non-Integer would fail to compile. This compile-time error is a big improvement over the run-time error since the former would occur during program development; whereas, the latter occurs during program use.
Summary: A log of Objects can be used
for any log; it is perfect for heterogeneous logs, but
can
degrade compile-time error into run-time errors for
homogeneous logs.
We will next see a
perfect solution (using Java
generics) for homogeneous logs.
Homework: 4.
Recall that ArrayStringLog is great for logs of Strings, ArrayIntegerLog is great for logs of Integers, etc. The problem is that you have to write each class separately even though they differ only in the type of the logs (Strings, vs Integers, vs etc). This is exactly the problem generics are designed to solve.
The idea is to parameterize the type as I now describe.
y1 = tan(5.1) + 5.13 + cos(5.12) y2 = tan(5.3) + 5.33 + cos(5.32) y3 = tan(8.1) + 8.13 + cos(8.12) y4 = tan(9.2) + 9.23 + cos(9.22) f(x) = tan(x) + x3 + cos(x2) y1 = f(5.1) y2 = f(5.3) y3 = f(8.1) y4 = f(9.2)
It would be boring and repetitive to write code like that on the top right (using mathematical not Java notation).
Instead you would define a function that parameterizes the numeric value and then invoke the function for each value desired. This is illustrated inn the next frame.
Compare the first y1 with f(x) and note that we replaced each 5.1 (the numeric value) by x (the function parameter). By then invoking f(x) for different values of the argument x we obtain all the ys.
In our example of ArrayStringLog and friends we want to
write one
parameterized class (in Java it would be called
a generic class and named ArrayLog<T>,
with T the type parameter) and then
instantiate
the parameter
to String, Integer, Circle, etc. to
obtain the equivalent of ArrayStringLog,
ArrayIntegerLog, ArrayCircleLog, etc.
public class ArrayLog<T> { private T[] log; private int lastIndex = -1; private String name; ... }
In many (but not all) places where ArrayStringLog had String, ArrayLog<T>, would have T. For example on the right we see that the log itself is now an array of Ts, but the name of the log is still a String.
We then get the effect of ArrayStringLog by writing ArrayLog<String>. Similarly we get the effect of ArrayIntegerLog by writing ArrayLog<Integer>, etc.
public interface LogInterface<T> { void insert(T element); boolean isFull(); int size(); boolean contains(T element); void clear(); String getName(); String toString(); }
In addition to generic classes such as ArrayLog<T>, we can also have generic interfaces such as LogInterface<T>, which is shown in its entirety on the right. Again note that comparing LogInterface<T> with StringLogInterface from the book, we see that some (but not all) Strings have been changed to Ts, and <T> has been added to the header line.
We will see several complete examples of generic classes as the course progresses.
The current situation is pretty good.
What's left?
Assume we want to keep the individual entries of the log is some order, perhaps alphabetical order for Strings, numerical order for Integers, increasing radii for circles, etc.
For this to occur, the individual items in the log must
be
comparable, i.e, you must be able to decide which of two
items
comes first.
This requirement is a restriction on the possible types that can be
assigned to T.
As it happens Java has precisely the notion that elements of a type can be compared to each other. The requirement is that the type extends the standard library interface called Comparable. Thus to have sorted logs, the element type T must implement the Comparable interface. In Java an array-based version would be written (rather cryptically) as
public class ArrayLog<T extends Comparable<T>> { ... }
We are not yet ready to completely understand that cryptic header.
We covered Java exceptions in 101 so this will be a review.
As a motivating example consider inserting a new log into a full ArrayStringLog. Our specification declared this to be illegal, but nonetheless, what should we do? The key point is that the user and not the implementer of ArrayStringLog should decide on the action. Java exceptions make this possible as we shall see.
An exceptional situation is an unusual, sometimes unpredictable event. It need not be fatal, but often is, especially if not planned for. Possibilities include.
impossibleoperation, such as popping an empty stack (which well cause an illegal array reference).
We will see that Java (and other modern programming languages) has support for exceptional conditions (a.k.a. exceptions). This support consists of three parts.
As we shall see an exception can be thrown from one piece of code and caught somewhere else, perhaps in a place far, far away.
This section is from my 101 class notes.
double s12 = p1.distTo(p2); if (s12!=p2.distTo(p3) || s12!=p3.distTo(p4) || s12!=p4.distTo(p1)) { System.out.println("Error: Rhombus with unequal sides"); System.exit(0); // an exception would be better } sidelength = s12;
double s12 = p1.distTo(p2); try { if (s12!=p2.distTo(p3) || s12!=p3.distTo(p4) || s12!=p4.distTo(p1)) throw new Exception("Rhombus with unequal side"); sidelength = s12; } catch (Exception ex) { System.out.println("Error: Rhombus with unequal sides"); System.exit(0); }
The top frame on the right shows (a slight variant of) the body of the Rhombus constructor. This constructor produces a rhombus given its four vertices. It terminates the run if the parameters are invalid (the side lengths are not all equal).
The frame below it shows one way to accomplish the same task using an exception. There are four Java terms introduced try, throw, catch, and Exception.
try and catch each introduce a block of code, which are related as follows.
matching(explained later) catch block is executed.
In the example code, if all the side lengths are equal, sidelength is set. If they are not all equal an exception in the class Exception is thrown, sidelength is not set, an error message is printed and the program exits.
This behavior nicely mimics that of the original, but is much more complicated. Why would anyone use it?
The answer to the above question is that using exceptions in the manner of the previous section to more-or-less exactly mirror the actions without an exception is not a good idea.
Remember the problem with the original solution. The author of the geometry package does not know what the author of the client wants to do when an error occurs (forget that I was the author of both). Without any such knowledge the package author terminated the run as there was no better way to let the client know that a problem occurred.
The better idea is for the package to detect the error, but let the client decide what to do.
The first step is to augment the Rhombus class with a constructor having three parameters: a point, a side-length, and an angle. The constructor produces the rhombus shown on the right (if Θ=Π/2, the rhombus is a square).
public Rhombus (Point p, double sideLength, double theta) { super (p, new Point(p.x+sideLength*Math.cos(theta), p.y+sideLength*Math.sin(theta)), new Point(p.x+sideLength*(Math.cos(theta)+1.), p.y+sideLength*Math.sin(theta)), new Point(p.x+sideLength, p.y)); this.sideLength = sideLength; }
double s12 = p1.distTo(p2); if (s12!=p2.distTo(p3) || s12!=p3.distTo(p4) || s12!=p4.distTo(p1)) throw new Exception ("Rhombus with unequal sides."); sideLength = s12;
try { rhom1 = new Rhombus(origin,origin,p2,p3); } catch (Exception ex) { System.out.printf("rhom1 error: %s Use unit square.\n", ex.getMessage()); rhom1 = new Rhombus (origin, 1.0, Math.PI/2.0); }
The constructor itself is in the 2nd frame.
This enhancement has nothing to do with exceptions and could have
(perhaps should have) been there all along.
You will see below how this
standard rhombus is used when the
client mistakenly attempts to construct an invalid rhombus.
The next step, shown in the 3rd frame, is to have the regular rhombus constructor throw an exception, but not catch it.
The client code is in the last frame. We see here the try and catch. In this frame the client uses the original 4-point rhombus constructor, but the points chosen do not form a rhombus. The constructor detects the error and raises (throws in Java-speak) an exception. Since the constructor does not catch this exception, Java automatically re-raises it in the caller, namely the client code, where it is finally caught. This particular client chooses to fall back to a unit square.
It is this automatic call-back provided by exceptions that enables the client to specify the action required.
Read the book's (Date) example, which includes information on creating exceptions and announcing them in header lines.
A Java exception is an object that is a member of either Exception, Error, or a subclass of one of these two classes.
throw new Exception ("Rhombus with unequal sides.");
On the right is the usage from my rhombus example above. As always the Java keyword new creates an object in the class specified. In the example, we do not name this object. We simply throw it.
public class GeometryException extends Exception { public GeometryException() { super(); } public GeometryException(String msg) { super(msg); } }
For simplicity, our example created an Exception. It is often convenient to have different classes of exceptions, in which case you would write code as shown on the right. This code creates a new subclass of Exception and defines two constructors to be the same as for the Exception class itself. (Recall that super() in a constructor invokes a constructor in the superclass.)
throw new GeometryException ("Rhombus with unequal sides.");
We would then modify the throw to create and raise an exception in this subclass.
We have seen that if an exception is raised in a method and not caught there, the exception is re-raised in the caller of the method. If it is also not caught in this second method, it is re-raised in that method's caller. This keeps going and if the exception is not caught in the main method, the program is terminated. Note that if f() calls g() calls h() calls k() and an exception is raised in k(), the handler (the code inside catch{}) is searched for first in k(), then h(), then g(), and then f(), the reverse order of the calling sequence.
In this limited sense, exceptions act similar to returns.
There is one more point that we need to review about exceptions and that is their (often required) appearance in method header lines. To understand when header line appearance is required, we examine the color coded class tree for Java exceptions shown on the right.
As always, Object is the root of the Java class tree and naturally has many children in addition to Throwable. As the name suggests, the Throwable class includes objects that can be thrown, i.e., Java exceptions.
For us, there are three important classes of pre-defined exceptions highlighted in the diagram: namely Error, Exception, and RuntimeException.
The red exceptions (and their white descendants)
are called
unchecked exceptions; the blue exceptions (and
their remaining white descendants) are called
checked exceptions.
The header line rule is now simple to state (but not as simple to
apply):
Any method that might raise a checked exception
must announce this fact in its header line using
the throws keyword.
For example, the rhombus constructor would be written as follows.
public Rhombus (Point p1, Point p2, Point p3, Point p4) throws Exception { super(p1, p2, p3, p4); // ignore this; not relevant to exceptions double s12 = p1.distTo(p2); if (s12!=p2.distTo(p3) || s12!=p3.distTo(p4) || s12!=p4.distTo(p1)) throw new Exception ("Rhombus with unequal sides."); sideLength = s12; }
The slightly tricky part comes when f() calls g(), g() calls h(), and h() raises a checked exception that it does not catch. Clearly, the header line of h() must have a throws clause. But, if g() does not catch the exception, then it is reraised in f() and hence g() must have a throws clause in its header line as well.
The point is that a method (g() above) can raise an exception even though it does not itself have a throw statement.
This makes sense since from the point of view of the caller of g() (method f() in this case), method g() does raise an exception so g() must announce that in its header.
When a method detects an error, three possible actions can occur.
Homework: 8.
We know that a stack is a list with LIFO (last-in, first-out) semantics and that it has three basic operations.
We choose to specify and implement a generic (homogeneous) stack. That is all elements of a given stack are of the same type, but different stacks can have elements of different type.
We use T for the element type, so our generic stack interface will be StackInterface<T>.
This is clearly an error so something must be done. We could simply add to the specification that top() and pop() cannot be called when the stack is empty, but that would be a burden for the client (even though we will supply an isEmpty() method).
We could try to handle the error in the pop() and top() methods themselves, but it is hard to see what would be appropriate for all clients. This leads to the chosen solution, an exception.
Our stack class will raise an exception when either top() or pop() is called when the stack is empty.
Rather that just using the Exception class, we will define our own exception. This immediately raises two questions: what should we name the exception and should it be checked or unchecked.
package ch03.stacks; public class StackUnderFlowException extends RuntimeException { public StackUnderFlowException() { super(); } public StackUnderFlowException(String msg) { super(msg); } } public class SUE extends RTE { public SUE() { super(); } public SUE(String msg) { super(msg); } }
The book names it StackUnderflowException as shown in the first frame on the right. A corresponding exception in the Java library is called EmptyStackException. A good feature of long names like these is that they are descriptive. A downside is that the code looks longer. Don't let the extra length due to the long names lead you to believe the situation is more complicated than it really is.
The second frame shows the same code assuming the exception was named SUE, and assuming that Java used RTE rather than RuntimeException, and omitting the package statement, which has nothing to do with the exception itself.
I am definitely not advocating short cryptic names; just pointing out how simple the StackUnderFlowException really is.
A more serious question is whether the exception should be checked or unchecked, i.e., whether it should extend Exception or RuntimeException.
import ch03.stacks.*; public class DemoStacks { public static void main(String[] args) { ArrayStack<Integer> stack = new ArrayStack<Integer>(); Integer x = stack.top(); } }
The code on the right shows the disadvantage of an unchecked exception. This simple main program creates an empty stack (we will learn ArrayStack soon) and then tries to access the top member, a clear error.
As we shall see, the code in top() checks for an empty stack and raises the StackUnderflowException when it finds one. Since top() does not catch the exception, it is reraised in the JVM (the environment that calls main() and a runtime error message occurs. Were the exception checked, the program would not compile since the constructor can throw a checked exception, which the caller neither catches nor declares in its header. In general compile time errors are better than runtime errors.
import ch03.stacks.*; public class DemoStacks { public static void main(String[] args) { ArrayStack<Integer> stack = new ArrayStack<Integer>(); stack.push(new Integer(3)); Integer x = stack.top(); } }
The very similar program on the right, however, shows the advantage of an unchecked exception. This time, the stack is not empty when top() is called and hence no exception is generated. This program compiles and runs with no errors. However, if the exception were checked, the program again would not compile, adding try{} and catch{} blocks would clutter the code, and a header throws clause, would be a false alarm.
The try{}...catch{} block pair can always be used as can the header throws clause. The choice between checked and unchecked errors is whether clients should be required or simply permitted to use these mechanisms.
A somewhat, but not completely, analogous situation occurs when trying to push an item onto a full stack. The reason the situation is not truly analogous is that conceptually, although a stack can be empty, it cannot be full.
Some stack implementations, especially those based on arrays, do produce stacks with an upper bound on the number of elements they can contain. Such stacks can indeed be full and these implementations supply both an isFull() method and a StackOverflowException exception.
public class SOE extends RTE { public SOE() { super(); } public SOE(String msg) { super(msg); } }
On the right is the corresponding StackOverflowException
class, written in the same
abbreviated style used above.
Note how stylized these exception definitions are.
Written in the abbreviated style, just three U's were changed to
O's.
Homework: 17.
Start Lecture #8
Remark: Give a better answer to class T extends S {} T t; S s; t=s; s=t;
Question: Do we tell clients that there is an isFull() method and mention the StackOverflowException that push() might raise? Specifically, should we put them in the interface?
If we do, then implementations that can never have a full stack, must implement a trivial version of isFull(). If we don't, then how does the client of an implementation that can have full stacks, find out about them?
One can think of several solutions: comments in the interface describing the features in only some implementations, a separate document outside Java, etc
We shall follow the book and use a hierarchy of three Java interfaces.
package ch03.stacks; public interface StackInterface<T> { void pop() throws StackUnderflowException; T top() throws StackUnderflowException; boolean isEmpty(); }
On the right we see the basic interface for all stacks. It is parameterized by T the type of the elements in the stack.
The interface specifies one mutator, two accessors, and one possibly thrown exception. Two points deserve comment.
package ch03.stacks; public interface BoundedStackInterface<T> extends StackInterface<T> { void push(T element) throws StackOverflowException; boolean isFull(); }
The first item to note concerning the code on the right is the extends clause. As with classes one interface can extend another. In the present case BoundedStackInterface inherits the three methods in StackInterface.
Since this extended interface is to describe stacks with an upper bound on the number of elements, we see that push() can raise an overflow exception. A predicate is also supplied so that clients can detect full stacks before causing an exception.
package ch03.stacks; public interface UnboundedStackInterface<T> extends StackInterface<T> { void push(T element); }
Perhaps the most interesting point in this interface is the observation that, although it might be a little harder to implement a stack without a bound, it is easier to describe. The concept of a full stack and the attendant exception, simply don't occur.
This simpler description suggests that the using an unbounded stack will be slightly easier than using a bounded one.
Imagine your friend John hands you three plates, a red, then a white, and then a blue. As you are handed plates, you stack them up. When John leaves, Mary arrives and you take the plates off the pile one at a time and hand them to Mary. Note that Mary gets the plates in the order blue, white, red the reverse from the order you received them.
It should be no surprise that this algorithm performs the same for Integers as it does for plates (it is what we would call a generic method. The algorithm is trivial push...push pop...pop.
import ch03.stacks.*; import java.util.Scanner; public class ReverseIntegers { public static void main(String[] args) { Scanner getInput = new Scanner(System.in); int n = getInput.nextInt(), revInt; BoundedStackInterface<Integer> stack = new ArrayStack<Integer>(n); for (int i=0; i<n; i++) stack.push(new Integer(getInput.nextInt())); for (int i=0; i<n; i++) { revInt = stack.top(); stack.pop(); System.out.println(revInt); } } }
A few comments on the Integer version shown on the right.
Homework: 18.
To help summarize the code in this chapter, here is the UML for the entire stack package
It is important not to let the fancy Java in this chapter (including more to come) hide the fact that implementing a stack with an array arr and an index idx is trivial: push(x) is basically arr[idx++]=x, top() is basically return arr[idx], and pop() is basically idx--.
The idea is that the elements currently in the stack are stored in the lowest indices of the array. We need to keep an index saying how much of the array we have used. The book has the index refer to the highest array slot containing a value; a common alternative is to have the index refer to the lowest empty slot; a frequent error is to do a little of each.
package ch03.stacks; public class ArrayStack<T> implements BoundedStackInterface<T> { private final int DEFSIZE = 100; private T[] stack; private int topIndex = -1; public ArrayStack(int size) { stack = (T[]) new Object[size]; } public ArrayStack() { this(DEFSIZE); }
The beginning of the class is shown on the right. We see from the header that it is generic and will implement all the methods in BoundedStackInterface (including those in StackInterface).
I changed the visibility of the fields from protected to private since I try to limit visibilities to private fields and public methods. I also used this to have the no-arg constructor invoke the 1-arg constructor.
I could spend half a lecture on the innocent
looking assignment to stack, which
should be
simply new T[size].
Unfortunately, that simple code would not compile, due to a weakness
in the Java implementation of generics, which does not permit the
creation of generic arrays (although it does permit their
declaration as we see on the right).
There is even a mini controversy as to why the weakness exists.
Accepting that new T[size] is illegal, the given code creates an array of Objects and downcasts it to an array of T's. For complicated reasons having to do with Java's implementation of generics, the downcast creates a warning claiming that it can't be sure the created array will be used correctly in all situations. We shall sadly have to accept the warning.
public boolean isEmpty() { return topIndex == -1; } public boolean isFull() { return topIndex == stack.length-1; }
For some reason the authors write these using if-then-else, converting trivial 1-liners into trivial 4-liners.
public void push(T element) { if (isFull()) throw new StackOverflowException("helpful msg"); else stack[++topIndex] = element; } public void pop() { if (isEmpty()) throw new StackUnderflowException("helpful msg"); else stack[topIndex--] = null; } public T top() { if (isEmpty()) throw new StackUnderflowException("helpful msg"); else return stack[topIndex]; }
These three methods, two mutators and one accessor, are the heart of the array-based stack implementation. As can be seen from the code on the right all are trivial.
pop() is not required to set the top value null. It is a safety measure to prevent inadvertently referring stale data.
My code assumes knowledge of the Java (really C) increment/decrement operators ++ and -- used both as prefix and postfix operators. The authors avoid using these operators within expressions, producing slightly longer methods. This result is similar to their using an if-then-else rather than returning the value of the boolean expression directly. I believe that Java programmers should make use of these elementary features of the language and that they quickly become idiomatic.
Homework: 28, 30
Read.
The interesting part of this section is the ArrayList class in the Java library. An ArrayList object has the semantics of an array that grows and shrinks automatically; it is never full. When an ArrayList used in place of an array, the resulting stack is unbounded. This library class is quite cool.
The essential point of well-formed expressions is that (all forms of) parentheses are balanced. So ({({[]})}) is well-formed, but ({({[]}})) is not. Note that we are concerned only with the parentheses so ({({[]})}) is the same as ({xds(45{g[]rr})l}l).
Why are stacks relevant?
When we see an open parenthesis, we stack it and continue. If we see another open, we stack it too. When we encounter a close it must match the most recent open and that is exactly the top of stack.
The authors present a more extensive solution than I will give. Their Balanced class permits one to create an object that checks balanced parentheses for arbitrary parentheses.
new Balanced("([{", ")]}") new Balanced("]x*,", "[y3.")
This approach offers considerable generality. The top invocation on the right constructs a Balanced object that checks for the three standard pairs of parentheses used above. The second invocation produces a weird object that checks for four crazy pairs of parentheses "][", "xy", "*3", and ",.".
For each input char if open, push if close, pop and compare if neither, ignore When finished, stack must be empty
Since the purpose is to illustrate the use of stack and I would like us to develop the code in class, let me simplify the problem a little and just consider ([{ and )]}. Also we require a whitespace between elements so that we can use the scanner's hasNext() and getNext() methods. With this simplification a rough description of the algorithm is on the right. A complete Java solution is here.
Start Lecture #9
Modern versions of Java, will automatically convert between an int and an Integer. This comes up in the book's solution for balanced parentheses since they push indices (int's not String's. Although we didn't need it, this autoboxing and autounboxing is quite useful and requires some comment.
The point is that int is a primitive type (not a class) so we cannot say ArrayStack<int> to get a stack of int's. The closest we can get is ArrayStack<Integer>.
stack.push(new Integer(i1)); stack.push(i1);
Assume stack is a stack of Integer's, and we want to push the value of an int variable i1. In older versions of Java, we would explicitly convert the int to an Integer by using a constructor as in the top line on the right. However Java 1.5 (current is 1.7) introduced the automatic conversion so we can use the bottom line on the right.
Homework: 36, 37(a-d).
As with StringLogs, both array- and link-based stack implementations are possible. Unlike arrays (but like ArrayLists), the linked structure cannot be full or overflow so it will be an implementation of UnboundedStackInterface.
package support; public class LLNode<T> { private LLNode<T> link = null; private T info; public LLNode (T info) { this.info = info; } public T getInfo() { return info; } public LLNode<T> getLink() { return link; } public void setInfo(T info) { this.info = info; } public void setLink(LLNode<T> link) { this.link = link; } }
Essentially all linked solutions have a
self-referential
node class with each node containing references to another node (the
link) and to some data that is application specific.
We did a specific case when implementing linked stringlogs.
A generic solution is on the right. The constructor is given a reference to the data for the node. Each of the two fields can be accessed and mutated, yielding the four shown methods.
Probably the only part needing some study is the use of genericity.
To motivate the implementation, on the far right is a detailed view of what should be the result of executing
UnboundedStackInterface<Integer> stack = new LinkedStack<Integer> (); stack.push(new Integer(10)); stack.push(20); // autoboxed
Remember that the boxes with rounded corners are objects and their class names is written outside the box. The rectangles contain references.
Normally, much less detail is shown than we see on the far right. Instead, one would draw a diagram like the one on the near right.
Do not let schematic pictures like this one trick you into
believing that the info field contains an int such as 20.
It cannot.
The field contains a T and T is
never int.
Why?
Answer: T must be a class; not a primitive type.
package ch03.stacks; import support.LLNode; public class LinkedStack<T> implements UnboundedStackInterface<T> { private LLNode<T> top = null; ... }
Since LLNode will be used in several packages, it is
placed in separate package and imported here.
The alternative is to replicate LLNode in every package
using it; a poor idea.
Why?
Answer: Replicated items require care to ensure changes are made to all copies.
The only data field is top, which points to the current top of stack.
An alternative to the field initialization shown would be to place write a constructor and place the initialization there. The book uses this alternative; the code shown does not need an explicit constructor, the no-arg constructor suffices.
On the right is a schematic view of the actions needed to insert a node onto an arbitrary linked list and to delete a node from such a linked list. For a stack, these operations correspond to push and pop respectively.
There is a potential point of confusion, due in part to terminology, that I wish to explain.
Recall that, for a stack, the list head (commonly called top) is the site for all insertions and for all deletions. This means that new nodes are inserted before the current first node and hence the new node becomes the first node.
As a result, if node A is inserted first and node B is inserted subsequently, then, although node A's insertion was temporally prior to node B's, node A appears after node B on the stack (i.e., access to node A comes after access to node B.
This ordering on the list gives the LIFO (last-in, first-out) behavior required for a stack.
The push() operation corresponds to the first line in the diagram above. The only difference is that we are inserting before the current first node so the red dashed pointer is the contents of the top field rather than the link field of a node.
public void push (T info) { LLNode<T> node = new LLNode<T>(info); node.setLink(top); top = node; }
From the diagram we see that the three steps are to create a new node, set the new link to the red link, and update the red link to reference the new node. Those three steps correspond one for one with the three lines of the method. A common error is to reverse the last two lines.
Show in class why reversing the last two lines fails.
Show in class that push() works correctly if the stack is empty when push() is called.
public void pop() throws StackUnderflowException { if (isEmpty()) throw new StackUnderflowException("helpful msg"); else top = top.getLink(); }
pop() corresponds to the second line of our diagram, again with the red pointer emanating from top, not from a node. So we just need to set the red arrow to the black one.
If the stack is empty, then the red arrow is null and there is no black arrow. In that case we have an underflow.
public T top() { if isEmpty() throw new StackUnderflowException("helpful msg"); else return top.getInfo(); }
public boolean isEmpty() { return top==null; }
top() simply returns the top element of the stack. If the stack is empty, an underflow is raised.
We must remember however that from the user's viewpoint, the stack consists of just the info components. The business with links and nodes is there only for our (the implementer's) benefit. Hence we apply getInfo().
Finally, a linked stack is empty if it's top field is null. Thus isEmpty() is a one-line method.
Both ArrayStack and LinkedStack are fairly simple and quite fast. All of the operations in both implementations are O(1), they execute only a fixed number of instructions independent of the size of the stack.
Note that the previous statement means that each push() takes only a constant number of instructions. Naturally pushing 1,000 elements takes longer (about 1000 times longer) than pushing one item.
The array-based constructor that is given the size of the array is not O(1) because creating an array of N Objects requires setting each of the N references to null. The linked-based constructor is O(1), which is better. Nonetheless, in a practical sense, both implementations are fast.
The two notable differences are
Homework: 40, 41, 45.
As mentioned at the beginning of this chapter, our normal arithmetic notation is called infix because the operator is in between the operands. Two alternatives notations are prefix (operator precedes the operands) and postfix (operator follows the operands).
As we know, with infix notation, some form of precedence rules are needed and often parentheses are needed as well. Postfix does not need either.
The evaluation rule is to push all operands until an operator is encountered in which case the operator is applied to the top two stacked elements (which are popped) and then the result is pushed (pop, pop, eval, pop).
Do several examples in class
The real goal is simply a method that accepts a postfix expression (a Java String) and returns the value of the expression. However, we cannot compile a naked method since, unlike some other languages, Java requires that each source file must be a class. Thus our goal will be a class containing a static method that evaluates postfix expressions. The class can be thought of as a simple wrapper around the method.
Read.
import ch03.stacks.*; import java.util.Scanner; public class PostfixEval { public static double postfixEval(String expr) { ... } }
As mentioned, we want to develop the method postfixEval(), but must package it as a class, which we have called PostfixEval. The skeleton is on the right, let's write the ... part in class.
For simplicity, we assume the argument to postfixEval() is a valid postfix expression.
A solution is here and a main program is here. The latter assumes each postscript expression is on a separate line.
export CLASSPATH="/a/dale-dataStructures/bookFiles/:." javac DemoPostfixEval.java java DemoPostfixEval
As a reminder this two-Java-files program can be compiled and run two ways. As written the program does not specify a package (technically it specifies the default package) so to compile and run it, go to its directory and execute the statements on the right.
export CLASSPATH="/a/dale-dataStructures/bookFiles/:." javac postfixEval/DemoPostfixEval.java java postfixEval/DemoPostfixEval
Alternatively (and good practice) is to use a named package. For example, add package postfixEval; at the top of each file, make sure the directory is also named postfixEval, go the parent of this directory and type the commands on the right.
Read.
Read. The book does not assume the postfix expression is valid so testing is more extensive than we would require.
Homework: 48, 49.
Several points were made in this chapter.
A recursive definition defines something in terms of (a hopefully simpler version of) itself.
It is easier to write this in elementary mathematics than Java. Consider these examples in order and only consider integer arguments.
For each of the following, can you evaluate f(3)? How about f(-8)? How about f(n) for all integers n?
1. f(n) = 1 + f(n-1) 2. f(n) = 1 + f(n-1) for n > 0 = 0 for n ≤ 0 (base case) 3. f(n) = 1 + f(n-1) for n > 0 f(0) = 0 f(n) = 1 + f(n+1) for n < 0 4. f(n) = 1 + g(n) g(n) = 1 + f(n-1) for n > 0 g(0) = 0 g(n) = 1 + f(n+1) for n < 0 5. f(n) = n * f(n-1) for n > 0 f(n) = 1 for n ≤ 0 6. f(n) = f(n-1) + f(n-2) for n > 0 f(n) = 0 for n ≤ 0 7. f(n) = f(n-1) + f(n-2) for n > 0 f(n) = 1 for n ≤ 0
The base case(s) occur(s) when the answer is expressed non-recursively.
Note that in most of the examples above f invokes itself directly, which is called direct recursion. However, in case 4, f invokes itself via a call to g, which is called indirect recursion. Similarly, g in this same example invokes itself via indirect recursion.
There is actually nothing special about recursive programs, except that they are recursive.
Here is a (not-so-beautiful) java program to compute any of the 7 examples above.
Number 5 is the well known factorial program and a non-recursive solution (write it on the board) is much faster.
Number 7 is the well known fibonacci program and a non-recursive solution (write it on the board) is much MUCH MUCH faster.
Start Lecture #10
If you have studied
proof by induction,
these questions should seem familiar.
smallerthan the caller instance? Actually this is not quite right, the callee can be bigger. What is needed is that eventually the callee gets smaller. (The book refers to this as the
smaller-callerquestion, but I don't like that name since, although the rhyming is cute, the meaning is backwards.)
In class, answer the questions for the not-so-beautiful program above.
Read. The main point is to recognize that the problem at a given size is much easier if we assume problems of smaller size can be solved. Then you can write the solution of the big size and just call yourself for smaller sizes.
You must ensure that each time (actually not each time, but eventually) the problem to be solved is getting smaller i.e., closer to the base case(s) that we do know how to solve non-recursively.
Your solution should have an if (or case) statement where one (or several) branches are for the base case(s).
One extra difficulty is that if you don't approach the base case the system runs out of memory and the error message basically just tells you that you aren't reaching the base case.
This game consists of 3 vertical pegs and n disks of different sizes (n=4 in the diagram below). The goal is to transform the initial state with all the disks on the left (From) peg to the final state with all disks on the middle (To) peg. Each step consists of moving the top disk of one peg to be the top disk of another peg.. The key rule is that, at no time, can a large disk be atop a small disk.
For example, the only two legal moves from the initial position are
For someone not familiar with recursion, this looks like a hard problem. In fact it is easy!
The base case is n=1 and moving a pile of 1 disks from peg From to peg To takes only one turn and doesn't even need peg Spare. In our notation the solution is 1:FT.
Referring to the picture let's do n=4. That is we want to move the 4-3-2-1 pile from peg From to peg To and can use the remaining peg if needed. We denote this goal as 4-3-2-1:FT and note again that the peg not listed (in this case peg Spare) is available for intermediate storage. Solving this 4-disk problem is a three-step solution.
Step 2 is simple enough. After step 1 peg F (From) has only one disk and peg T has none so of course we can move the lone disk from F to T. But steps 1 and 3 look like the another hanoi problem.
Exactly. That's why were done!!
Indeed the solution works for any number of disks. In words the algorithm is: to move a bunch of disks from one peg to another, first, move all but the bottom disk to the remaining (spare) peg, then move the bottom disk to the desired peg, and finally move the all-but-the-bottom pile from the spare to the desired peg.
Show some emacs solutions. The speed can be changed by customizing `hanoi-move-period'.
How many individual steps are required?
Let S(n) be the number of steps needed to solve an n-disk hanoi problem.
Looking at the algorithm we see.
These two equations define what is called a recurrence. In Basic Algorithms (310), you will learn how to solve this and some other (but by no means all) recurrences.
In this class we will be informal. Note that equation 2 says that, if n grows by 1, S(n) nearly doubles.
What function doubles when its argument grows by 1?
Answer: f(n) = 2n
So we suspect the answer to our recurrence will be something like 2n. In fact the answer is S(n)=2n-1.
Let's check S(1)=21-1=2-1=1. Good.
Does S(n)=2S(n-1)+1 as required? We need to evaluate both sides and see.
S(n)=2n-1
2S(n-1)+1 = 2(2n-1-1)+1 = 2n-2+1 = 2n-1 as required.
I feel bound to report that there is another simple solution, one
that does not use recursion.
It is not simple to see that it works and it is not
as
elegant as the recursive solution (at least not to my
eyes).
Do one in class.
public class Hanoi1 { public static void main (String[] args) { hanoi(4, 'F', 'T', 'S'); } public static void hanoi(int n, char from, char to, char spare) { if (n>0) { hanoi(n-1, from, spare, to); System.out.println(n + ":" + from + to); hanoi(n-1, spare, to, from); } } }
On the right is a bare-bones solution. Clearly the main program should read in the value for n instead of hard-wiring 4 and the output is spartan. I did this to show that the algorithm itself really is easy: the hanoi() method just has three lines, directly corresponding to the three lines in the algorithm.
Read.
The book's program accepts input, which it error checks, and invokes its hanoi() method. The latter produces more informative output, which is indented proportional to the current depth of recursion.
Read.
Start Lecture #11
Remark: Lab 3 assigned. The wording on 3B was improved Sunday morning.
Definition: A Graph is a data structure consisting of nodes and edges. An edge is viewed as a line connecting two nodes (occasionally the two nodes are equal and the edge is then often referred to as a loop).
Definition: A graph is called Directed if the each edge has a distinguished start and end. These edges are drawn as arrows to indicate their direction and such directed edges are normally called arcs.
On the right we see a small directed graph. It has 6 nodes and 7 arcs. We wish to determine reachability, that is for each node, we want to know which nodes can be reached by following a path of arcs.
A node, by definition, can reach itself. This can be thought of as following a path of zero arcs.
For example the reachability of the drawn graph is
0: 0 1 2 3 4 5 1: 1 2 4 5 2: 1 2 4 5 3: 3 4: 4 5: 4 5.
One question we must answer is how do we input the graph. We will use what could be called incidence lists. First we input the number of nodes and then, for each node, give the number of nodes directly reachable and a list of those nodes.
For example, the input for the drawn graph is 6 2 1 3 2 2 4 2 1 5 0
0 1 4.
Written in the notation used above for reachability, the given arcs
are
0: 1 3 1: 2 4 2: 1 5 3: 4: 5: 4.
for each successor the successor is reachable recurse at this successor
To compute reachability we begin by noting that each node is reachable from itself (as mentioned above) and then apply the algorithm on the right.
Let's say we want to know which nodes are reachable from 2. In the beginning we know only that 2 is reachable from 2. The algorithm begins by looking at the successors of 2, i.e., the destinations of the arcs that start at 2. The first successor we find is 1 so we recursively start looking for the successors of 1 and find 4 (so far the nodes reachable from 2 are 2, 1, and 4).
Then we recursively look for successors of 4. There are none so we have finished looking for the successors of 4 and return to the successors of 1.
There is an infinite loop lurking, do you see it?
The next successor of 1 is 2 so we should now look for successors of 2. But, if we look for successors of 2, will find 1 (and 5) and recursively start looking (again) for successors of 1, then find 2 as a successor of 1, which has 1 as a successor, which ... .
The loop 1 to 2 to 1 to 2 ... is endless. We must do better.
for each successor if the successor is not listed list it recurse at this successor
The fix is that we do not recurse if we have already placed this node on the list of reachable nodes. On the right we see the pseudocode, with this correction.
Let's apply this pseudocode to find the nodes reachable from 2, remembering that, by definition, 2 is reachable from 2.
The full Java solution is here and I have a handout so that you can read it while something else is on the screen.
This class has two fields:
The constructor is given the number of nodes and creates the fields.
Since the fields have private access, there are methods to set and get various values.
The main program reads input and sets the values in the arcs array. For example, to match our graph the input would be 6 2 1 3 2 2 4 2 1 5 0 0 1 4 as described above. With this input arcs.length==6, arcs[0].length==2, arcs[0,0]==1, arcs[0,1]=3, etc.
The arcs ragged array could be written as follows (the two blank lines represent the fact that there are no arcs leaving nodes 3 and 4).
1 3 2 4 1 5 4
In class draw the arcs ragged array showing the full Java details.
The two print routines are straightforward; we shall see their output in a few minutes.
CalcReachability() itself does very little.
As indicated, the helper does the real work. It is basically the pseudocode above translated into Java.
One interesting question is, "Where is the base case?".
It is not trivial to find, but it is there! The base case is the case when each successor has already been marked reachable. Note that in this case, the if predicate evaluates to false for each iteration. Thus the method returns without calling itself recursively.
Question: What does this method accomplish,
It doesn't ever return a value?
Answer: It (sometimes) modifies the reachable parameter.
Question: How can that be an accomplishment since Java is call-by-value and changes to parameters are not seen by the caller?
Answer: The usual answer ...
... reference semantics.
Go over execution of the entire program on the input used for the diagram above.
Homework: Draw a directed graph with 7 nodes so that node 1 can reach all nodes and all other nodes can reach only themselves.
For this section we are considering only what are called
singly-linked lists where all the link pointers go in the same
direction.
All our diagrams to date have been of singly-linked lists, but we
will also study doubly-linked lists, which have pointers in both
directions (so called
next and
prev pointers).
If we use a loop to process a (singly-)linked list, we can go only forwards so it becomes awkward when we need to access again a node that we have previously visited.
With recursive calls instead of a loop, we will visit the previous links again when the routines return. Hopefully, the next example with make this clear
Hand out a copies of LLStringNode.java and DemoReversePrint.java, which might not fit conveniently on the screen. These routines can also be found here.
public class LLStringNode { private String info; private LLStringNode link = null; public LLStringNode(String info) { this.info = info; } public String getInfo() { return info; } public void setInfo(String info) { this.info = info; } public LLStringNode getLink() { return link; } public void setLink(LLStringNode link) { this.link = link; } } public class DemoReversePrint { public static void main (String[] args) { LLStringNode node1 = new LLStringNode("node # 1"); LLStringNode node2 = new LLStringNode("node # 2"); LLStringNode node3 = new LLStringNode("node # 3"); LLStringNode node4 = new LLStringNode("node # 4"); node1.setLink(node2); node2.setLink(node3); node3.setLink(node4); System.out.println("Printing in original order"); printFor(node1); System.out.println("Printing in reverse order"); printRev(node1); System.out.println("Printing forward recursively"); printForRec(node1); } public static void printFor(LLStringNode node) { while (node != null) { System.out.println(" " + node.getInfo() ); node = node.getLink(); } } public static void printRev(LLStringNode node) { if (node.getLink() != null) printRev(node.getLink()); System.out.println (" " + node.getInfo() ); } public static void printForRec(LLStringNode node) { System.out.println (" " + node.getInfo() ); if (node.getLink() != null) printForRec(node.getLink()); } }
LLStringNode.java is quite simple. Each node has two fields, the constructor initializes one and there is a set and get for each.
The main program first creates a four node list
node1-->node2-->node3-->node4 and then prints it three times. The first time the usual while loop is employed and the (data components of the) nodes are printed in the their original order.
The second time recursion is used to get to the end of the list (without printing) and then printing as the recursion unwinds. Show this in class.
The third time recursion is again used but values are printed as the recursion moves forward not as it unwinds. Show in class that this gives the list in the original order.
while (node != null) push info on stack node = node.getLink() While (!stack.empty()) print stack.top() stack.pop()
On the right we see pseudocode for a non-recursive, reversing print. As we shall soon see the key to implementing recursion is the clever use of a stack. Recall that an important property of dynamically nested function calls is their stack-like LIFO semantics. If f() calls g() calls h(), then the returns are in the reverse order h() returns, then g() returns, then f() returns.
Consider the recursive situation main calls f() calls f() calls
f().
When the first call occurs we store the information about the f() on
a stack.
When the second call occurs, we again store the information, but now
for the
second f().
Similarly, when the third calls occurs, we store the information for
the
third f().
When this
third f() returns, we pop the stack and have
restored the environment of the
second f().
When this invocation of f() returns, we pop again and have restored
the environment of the original f().
This is shown in more detail just below.
Homework: The printFor() method prints each node once. Write printForN(), which prints the first node once, the second node twice, the third node three times, ..., the Nth node N times.
If f() calls f() calls f() ..., we need to keep track of which f we
are working on.
This is done by using a stack and keeping a chunk of memory
(an
activation record) for each active execution of f().
The first diagram below shows the life history of the activation
stack for an execution of f(2) where f() is the fibonacci function
we saw at the beginning of the chapter.
Below that is the activation stack for f(3).
At all times the system is executing the invocation at the current top of the stack and is ignoring all other invocations.
n = getInput.nextInt(); double[] x = new double[n];
Some older programming languages (notably old versions of Fortran) did not have recursion and required all array bounds to be constant (so the Java code on the right was not supported). With these some languages the compiler could determine, before execution began where each variable would be located.
This rather rigid policy is termed static storage allocation since the storage used is fixed prior to execution beginning.
In contrast to the above, newer languages like Java support both recursion and arrays with bounds known only during run time. For these languages additional memory must be allocated while execution occurs. This is called dynamic storage allocation.
One example, which we have illustrated above is the activation stack for recursive programs like fibonacci.
There is one case where it is easy to convert a recursive method to an iterative one. A method is called tail-recursive if the only recursion is at the tail (i.e., the end). More formally
Definition: A method f() is tail-recursive if the only (direct or indirect) recursive call in f() is a direct call of f() as the very last action before returning.
The big deal here is that when f() calls f()
and the 2nd f() returns, the first f()
returns immediately thereafter.
Hence we do not have to keep all the
activation records.
int gcd (int a, int b) { int gcd (int a, int b) { start: if (a == b) return a; if (a == b) return a; if (a > b) if (a > b) { return gcd(a-b,b); a = a-b; goto start; } return gcd(a,b-a); } b = b-a; goto start; }
As an example consider the program on the near right. This program computes the greatest common divisor (gcd) of two positive integers. As the name suggests, the gcd is the largest integer that (evenly) divides each of the two given numbers. For example gcd(15,6)==3.
Do gdc(15,6) on the board showing the activation stack.
It is perhaps not clear that this program actually computes the correct value even thought it does work when we try it. We are actually not interested in computing gcd's so let's just say we are interested in the program on the near right and consider it a rumor that it does compute the gcd.
Now look at the program on the far right above. It is not legal Java since Java does not have a goto statement. The (famous/infamous/notorious?) goto simply goes to the indicated label.
Again execute gcd(15,6) and notice that it does the same thing as the recursive version but does not make any function calls and hence does not create a long activation stack.
Remark: Good compilers,
especially those for
functional languages, which make heavy
use of recursion, automatically convert tail recursion to
iteration.
Recursion is a powerful technique that you will encounter frequently in your studies. Notice how easy it made the hanoi program.
It is often useful for linked lists and very often for trees. The reason for the importance with trees is that a tree node has multiple successors so you want to descend from this node several times. You can't simply loop to go down since you need to remember for each level what to do next.
Draw a picture to explain and compare it to the fibonacci activation stack picture above.
Start Lecture #12
Remark: Wording change in honors supplement.
Whereas the stack exhibits LIFO (last-in/first-out) semantics, queues have FIFO (first-in/first-out) semantics. This means that insertions and removals occur at different ends of a queue; whereas, they occur at the same end of a stack.
A good physical example for stacks is the dish stack at hayden; a good physical example for a queue is a line to buy tickets or to be served by a bank teller. In fact in British English such lines are called queues.
Following the example of a ticket line, we call the site where items are inserted the rear of the queue and the site where items are removed the front of the queue.
Personally, I try to reserve the term
queue for the
structure described above.
Some call a stack a LIFO queue (I shudder when I hear that) and
thus call a queue a FIFO queue.
Unfortunately, the term
priority queue is absolutely
standard and refers to a structure that does not have FIFO
semantics.
We will likely discuss priority queues later this semester, but not
in this chapter and never by the simple name
queue.
As with stacks there are two basic operations: insertion and removal. For stacks those are called push and pop; for queues they are normally called enqueue and dequeue.
We have discussed
real-world examples, but queues are very
common in computer systems.
One use is for speed matching. Here is an example from 202 (operating systems). A disk delivers data at a fixed rate determined by the speed of rotation and the density of the bits on the medium. The OS cannot change either the bit density or the rotation rate. If software can't keep up (for example the processor is doing something else), the disk cannot be slowed or stopped. Instead the arriving data must be either saved or discarded (both options are done).
When the choice is to save the data until needed, a queue is used so that the software obtaining the data, gets it in the same order it would have were it receiving the data directly from the disk.
This use of a queue is often called buffering and these queue are often called buffers.
As with stacks, we will distinguish between queues having limited capacity (bounded queues) from those with no such limit (unbounded queues). Following the procedure used for stacks, we give 3 interfaces for queues: the all inclusive QueueInterface, which describes the portion of the interface that is common to both bounded and unbounded queues; BoundedQueueInterface, the extension describing bounded queues; and UnBoundedQueueInterface, the extension for unbounded queues.
On the right we see the relationship between the three interfaces.
Recall that the arrows with single open triangles
signify
extends.
For example, BoundedQueueInterface extends
QueueInterface.
Below we see a larger diagram covering all the interfaces and classes introduced in this chapter.
package ch05.queues; public interface QueueInterface<T> { T dequeue() throws QueueUnderflowException; boolean isEmpty(); }
For any queue we need enqueue and dequeue operations. Note, however, that the enqueue is different for bounded and unbounded queues. A full bounded queue cannot accommodate another element. This cannot not occur for an unbounded queue, which cannot be full. Thus both the isFull() predicate and the enqueue() mutator cannot be specified for an arbitrary queue. As a result only the isEmpty() predicate and the dequeue() mutator are specified.
If the mutator encounters an empty queue, it raises and exception.
package ch05.queues; public interface BoundedQueueInterface<T> { void enqueue(T element) throws QueueOverflowException; boolean isFull(); }
For bounded queues we do need an isFull() predicate and the enqueue() method, when encountering a full queue, throws an exception.
package ch05.queues; public interface BoundedQueueInterface<T> { void enqueue(T element);
Unbounded queues are simpler to specify. Since they are never full, there is no isFull() predicate and the enqueue() method does not raise an exception.
Note the following points that can be seen from the diagram.
underflow.
import ch05.queues.*; import java.util.Scanner; public class DemoBoundedQueue { public static void main (String[] args) { Scanner getInput = new Scanner(System.in); String str; BoundedQueueInterface<Integer> queue = new ArrayBndQueue<Integer>(3); while (!(str=getInput.next()).equals("done")) if (str.equals("enqueue")) queue.enqueue(getInput.nextInt()); else if (str.equals("dequeue")) System.out.println(queue.dequeue()); else System.out.println("Illegal"); } }
The example in the book creates a bounded queue of size three; inserts 3 elements; then deletes 3 elements. That's it.
We can do much more with a 3 element queue. We can insert and delete as many elements as we like providing there are never more than three enqueued.
For example, consider the program on the right. It accepts three kinds of input.
An unbounded number of enqueues can occur just as long as there are enough dequeues to prevent more than 3 items in the queue at once.
The Java library has considerably more sophisticated queues than the ones we will implement, so why bother? There are several reasons.
class SomethingOrOtherQueue<T>
All these implementations will be generic so each will have a header line of the form shown on the right, where T is the class of the elements.
For example the ArrayBndQueue<Integer> class will
be an array-based bounded queue of Integer's.Remember
that ArrayBndQueue<float> is illegal.
Why?
Answer float is a primitive type, and a class type (e.g. Float) is required.
The basic idea is clear: Store the queue in an array and keep track of the indices that correspond to the front and rear of the queue. But there are details.
The book's (reasonable) choice is that the current elements in the queue start at index front and end at index rear. Some minor schenanigans are needed for when the queue has no elements
First we try to mimic the stack approach where one end of the list is at index zero and the other end moves. In particular, the front index is always zero (signifying that the next element to delete is always in slot zero), and the rear index is updated during inserts and deletes so that it always references the slot containing the last item inserted.
The following diagram shows the life history of a ArrayBndQueue<Character> class of size 4 from its creation through four operations, namely three enqueues and one dequeue.
Since the Front of the queue is always zero, we do not need to keep track of it. We do need a rear data field.
Go over the diagram in class, step by step.
Note that the apparent alias in the last frame is not a serious problem since slot number 2 is not part of the queue. If the next operation is an enqueue, the alias will disappear. However, some might consider it safer if the dequeue explicitly set the slot to null.
Homework: Answer the following questions (discuss them in class first)
This queue would be easy to code, let's sketch it out in class.
This queue is simple to understand and easy to program, but is not normally used. Why?
The loop in dequeue() requires about N steps if the currently N elements are enqueued. The technical terminology is that enqueue() is O(1) and dequeue() is O(N).
CircularArrays)
This next design will have O(1) complexity for
both enqueue() and dequeue().
We will see that it has an extra
trick (modular arithmetic)
and needs a little more care.
As mentioned in the very first lecture, we will sometimes give up
some simplicity for increased performance.
The following diagram shows the same history as the previous one, but with an extra dequeue() at the end. Note that now the value of Front changes and thus must be maintained.
Note first that the last frame represents a queue with only one element. Also note that, similar to the previous diagram, the apparent aliases aren't serious and can be eliminated completely by setting various slots null.
We might appear to be done, both operations are O(1). But, no.
Imagine now three more operations enqueue('D'); dequeue(); enqueue('E'); The number of elements in the queue goes from the current 1, to 2, back to 1, back to 2.
However, it doesn't work because the value of Rear is now 4, which does not represent a slot in the array.
Note that alternating inserts and deletes move both Front and Rear up, which by itself is fine. The trouble is we lose the space below!
That is why we want a circular array so that we consider the slot after 3 to be slot 0. The main change when compared to the previous implementation is that instead of rear++ or ++rear we will use rear=(rear+1)%size
In the fixed-front implementation the number of elements in the queue was Rear+1 so, by maintaining Rear, we were also tracking the current size. That clearly doesn't work here as we can see from the picture just above. However the value Rear+1-Front does seem to work for the picture and would have also worked previously (since then Front was 0).
Nonetheless in the present implementation we will separately track the current size. See the next (optional) section for the reason why.
I will follow the book and explicitly track the number of elements in the queue (adding 1 on enqueues and subtracting 1 on dequeues). This seem redundant as mentioned in the immediately preceding section.
But what happens when Rear wraps around, e.g., when we enqueue two more elements in the last diagram? Rear would go from 2 to 3 to 0 and (Rear-Front)+1 becomes (0-2)+1=-1, which is crazy. There are three elements queued, certainly not -1. However, the queue size is 4 and -1 mod 4 = 3. Indeed (Rear+1-Front) mod Capacity seems to work.
But now comes the real shenanigans about full/empty queues. If you carry out this procedure for a full queue and for an empty queue you will get the same value. Indeed using Front and Rear you can't tell full and empty apart.
One solution is to declare a queue full when the number of elements is one less than the number of slots. The book's solution is to explicitly count the number of elements, which is fine, but I think the subtlety should be mentioned, even if only as a passing remark.
The fixed-front is simpler and does not require tracking the current size. But the O(N) dequeue complexity is a serious disadvantage and I believe the circular queue implementation is more common for that reason.
This class is simple enough that we can get it (close to) right in class ourselves. The goal is that we write the code on the board without looking anywhere. To simplify the job, we will not worry about QueueInterface, BoundedQueueInterface, packages, and CLASSPATH.
You should compare our result with the better code in the book.
We certainly need the queue itself, and the front and rear pointers to tell us where to remove/insert the next item. As mentioned we also need to explicitly track the number of elements currently present. We must determine the correct initial values for front and rear, i.e. what their values should be for an empty queue.
Finally, there is the sad story about declaring and allocating a generic array (an array whose component type is generic).
Although we are not officially implementing the interfaces, we will supply all the methods mentioned, specifically dequeue(), enqueue(), isEmpty(), and is isFull().
I grabbed the main program from the end of section 5.2 (altered it slightly) and stuck it at the end of the class we just developed. The result is here.
In chapter 3 on stacks, after doing a conventional array-based
implementation, we mentioned the Java library
class ArrayList, which implements an
unbounded array, i.e., an array that grows in size when
needed.
Now, we will implement an unbounded array-base
queue.
The idea is that an insert into a full queue, increases the size of the underlying array, copies the old data to the new structure, and then proceeds. Specifically, we need to change the following code in ArrayBndQueue. The diagram shows a queue expansion.
Let's do the mods in class. The first step is to figure out enlarge() based on the picture.
The UML diagrams are helpful for writing applications so here is the full one for queues, including linked types we haven't yet studied.
Start Lecture #13
Homework: 1, 2, 6 (these three should have been assigned earlier) 13.
This simple program proceeds as follows. Read in a string and then push (on a stack) and enqueue (on a queue) each element. Finally, pop and dequeue each element. To be a palindrome, the first element popped must match the first element dequeued, the second popped must match the second dequeued, etc.
public class Palindrome { public static boolean isPalindrome(String str) { ... } }
Recall that a palindrome reads the same left to right as right to left. Lets write the predicate isPalindrome() using the following procedure.
Note that this is not a great implementation; it is being used just to illustrate the relation between stacks and queues. For a successful match each character in the string is accessed 5 times.
A better program (done in 101!) is to attack the string with charAt() from both ends. This accesses each character only once.
Indeed, if our 102 solution didn't use a queue and just reaccessed the string with charAt() a second time, we would have only 4 accesses instead of 5.
The book's program only considers letters so
AB?,BA would
be a palindrome.
This is just an early if statement to ignore non letters
(the library Character class has an isLetter()
predicate, which does all the work.
Normal I/O and use the palindrome class.
Read.
In this card game you play cards from the top and, if you win
the
battle, you place the won cards at the bottom.
So each player's hand can be modeled as a queue.
main() loop N times flip a coin if heads produce() else consume() produce() if queue is not full generate an item enqueue the item consume() if queue is not empty dequeue an item print the item
A very real application of queues is for producer-consumer problems where some processes produce items that other processors consume. To do this properly would require our studying Java threads, a fascinating (but very serious) topic that sadly we will not have time to do.
For a real world example, imagine email. At essentially random times mail arrives and is enqueue. At other essentially random times, the mailbox owner reads messages. (Of course, most mailers permit you to read mail out of order, but ignore that possibility).
We model the producer-consumer problem as shown on the right. This model is simplified from reality. If the queue is full, our produce is a no-op; similarly for an empty queue and consume.
As you will learn in 202, if the queue is
full, all producers are
blocked, that is, the OS stops
executing producers until space becomes available (by a consumer
dequeuing an item).
Similarly, consumers are blocked when the queue is empty and wait
for a producer to enqueue an item.
This is easy. Ask Math.random() for a double between 0 and 1. If the double exceeds 0.5, declare the coin heads. Actually this is flipping a fair coin. By changing the value 0.5 we can change the odds of getting a head.
A simple Java program, using the book's ArrayBndQueue is here.
By varying the capacity of the queue and N, we can see the importance of sufficient size queues. I copied the program and all of .../ch05/queues to i5 so we can demo how changing the probability of heads affects the outcome.
As with linked stacks, we begin linked queues with a detailed diagram showing the result of creating a two node structure, specifically the result of executing.
UnboundedQueueInterface<Integer> queue = LinkedUnBndQueue<Integer>(); queue.enqueue(new Integer(10)); queue.enqueue(20); // Uses autoboxing
Normally, one does not show all the details we have on the right, especially since some of them depend on Java. A typical picture for this queue is shown below. Given the Java code, you should be able to derive the detailed picture on the right from the simplified picture below.
Homework: 30.
The goal is to add a new node at the rear. An unbounded queue is never full, so overflow is not a concern.
Your first thought might be that this is a simple 3-step procedure.
There is a subtle failure lurking here.
Presumably, the
current last node is the one currently
pointed to by rear.
That assertion is correct most, but not all, of the
time, i.e., it is wrong.
The failure occurs when inserting into an empty queue, at which point rear does not point to the last node; instead rear==null.
The fix is to realize that for an initially empty queue we want front (rather than the non-existent last node) to point to the new node.
To motivate this last statement, first imagine inserting into the queue drawn above, which currently contains the Integers 10 and 20. You want the new node to be the successor of (i.e., be pointed to by) the 20-node, which is two nodes after front.
Now imagine a smaller queue with only the 10-node; this time the new node should be the successor of the 10-node, which is one node after front.
public void enqueue(T data) { LLNode<T> newNode = new LLNode<T>(data); if (isEmpty()) front = newNode; else rear.setLink(newNode); rear = newNode; }
Now imagine a yet smaller queue with no nodes. By analogy, this time the new node should be the successor of the node zero nodes after front, i.e., it should be the successor of front itself
The resulting method is shown on the right.
The goal is to remove the front node. As with enqueue, dequeue seems simple.
public T dequeue() { if (isEmpty()) throw new QueueUnderflowException("Helpful msg"); T ans = front.getInfo(); front = front.getLink(); if (front == null) rear = null; return ans; }
Again this works only most of the time, i.e., is wrong.
Clearly we can't dequeue from an empty queue. Instead we raise an exception.
The more subtle concern involves a 1-element queue. In this case front and rear point to the node we are removing. Thus we must remember to set rear=null, as shown in the code on the right.
Since QueueUnderflowException is unchecked, we are not required to include a throws clause in the method header.
package ch05.queues; import support.LLNode; public class LinkedUnbndQueue<T> implements UnboundedQueueInterface<T> { private LLNode<T> front=null, rear=null; public boolean isEmpty() { return front == null; } public void enqueue(T data) { // shown above } public T dequeue() { // shown above } }
The entire package is on the right. An empty queue has front and rear both null. A nonempty queue has neither null, so isEmpty() is easy.
The implementation on the right uses the generic LLNode class found in the support package.
If we are a little clever, we can omit the front pointer. The idea is that, since the link component of the rear node is always null, it conveys no information. Instead of null we store there a pointer to the first node and omit the front data field from the queue itself.
The result, shown on the right, is often called a circular queue. Although it clearly looks circular, one could say that it doesn't look like a queue since it doesn't have two ends. Indeed, from a structural point of view view it has no ends. However, we can write enqueue and dequeue methods that treat the rear as one end and the successor-of-rear (which is the front) as the other end.
An empty queue has rear null and a one element queue has the single node point to itself. Some care is needed when constructing the methods to make sure that they work correctly for such small queues (the so-called boundary cases).
The rough comparison is similar to the stack situation and indeed many other array/linked trade-offs.
With the linked implementation you only allocate as many nodes as you actually use; the unbounded array implementation approximates this behavior; whereas, for the bounded array implementation, you must allocate as many slots as you might use.
However, each node in a linked implementation requires a link field that is not present in either array implementation.
All are fast. The linked enqueue requires the runtime creation of memory, which costs more than simple operations. However, the array constructors requires time O(#slots) since java initializes each slot to null and the unbounded array constructor copies elements.
We run races below.
Read.
The goal is to quantify how fast the queues are in practice. We will compare the two unbounded queues. Since they both implement the same interface we can declare them to be the same type and write one method that accepts either unbounded queue and performs the timing.
There are many possibilities, what I chose was to enqueue N elements and then dequeue them. This set of 2N operations was repeated M times.
The results obtained for N=1,000,000 and M=1,000 were
An array-based unbounded queue requires 71216 milliseconds to enqueue and dequeue 1000000 elements 1000 times. A linked-based unbounded queue requires 31643 milliseconds to enqueue and dequeue 1000000 elements 1000 times.
So 2 billion operations take about 50 seconds or 40MOPS (Millions of Operations Per Second), which is pretty fast.
Timing events is fairly easy in Java, as usual this is due to the extensive library. For this job, it is the Date class in java.util that performs the heavy lifting.
When you create a date object (using new of course), a field in the object is initialized to represent the current time and this value can be retrieved using the getTime() method.
Specifically, the value returned by getTime() is the number of milliseconds from a fixed time to the time this date object was created. That fixed time happens to be 1 January 1970 00L00:00 GMT, but any fixed time would work.
Therefore, if you subtract the getTime() values for two Date objects, you get the number of milliseconds between their creation times.
Let's write a rough draft in class. My solution is here.
Queues are an important data structure. Their key property is the FIFO behavior exhibited by enqueues and dequeues.
We have seen three implementations, an array-based implementation where each created queue is of a fixed size, and both array-based and linked-based implementations where queue grow in size as needed during execution.
Remark: End of Material on Midterm.
Start Lecture #14
Start Lecture #15
Start Lecture #16
Remarks:
Lists are very common in both real life and computer programs. Software lists come in a number of flavors and the division into subcategories is not standardized.
The book and I believe most authors/programmers use the term list
in a quite general manner.
The Java library, however, restricts a list to be ordered.
The most general list-like interface in the library
is Collection<E>, and the (very extensive)
ensemble of classes and interfaces involved is called the
Collection Framework.
The library is rather sophisticated and detailed; many of the classes involved implement (or inherit) a significant number of methods. Moreover, the implementations strive for high performance. We shall not be so ambitious.
Differences between various members of the collection include.
We will be defining predicates contains() that determine if a given list contains a given element. For this to make sense, we must know when two elements are equal.
Since we want some lists to be ordered, we must be able to tell if one element is less than another.
We have seen that, for objects, the == operator tests if the references are equal, not if the values in the two objects are equal. That is, o1==o2 means that both o1 and o2 refer to the same objects. Sometimes the semantics of == is just right, but other times we want to know if objects contain the same value.
Recall that the Object class defines an equals() method that has the == semantics. Specifically, o1.equals(2) if and only if both refer to the same value.
Every class is a descendant of object, so equals() is always defined. Many classes, however, override equals() to give it a different meaning. For example, for String's, s1.equals(s2) is true if and only if the two strings themselves are equal (not requiring that the references are equal).
Imagine a Circle class having three fields double r,x,y giving the center of the circle and its radius. We might decide to define equals() for circles to mean that their radii are equal, even though the centers are different. That is, equals() need not mean identical.
public boolean equals (Circle circle) { return this.radius == circle.radius; } public boolean equals (Object circle) { if (circle instanceof Circle) return this.radius == ((Circle) circle).radius; return false; }
The definition of equals() given by Dale is simple, but flawed due to a technical fine point of Java inheritance. The goal is for two circles to be declared equal if they have equal radii. The top code on the right seems to do exactly that.
Unfortunately, the signature of this method differs from the one defined in Object, so the new method only overloads the name equals(). The bottom code does have the same signature as the one in Object, and thus overrides that method.
The result is that in some circumstances, the top code will cause circles to be compared using the equals() defined in Object. The details are in Liang section 11.10 (the 101 text) and in the corresponding section of my 101 lecture notes.
Homework: 1, 2.
To support an ordered list, we need more than equality testing. For unequal items, we need to know which one is smaller. Since I don't know how to tell if one StringLog is smaller than another, I cannot form an ordered list of StringLog's.
As a result, when we define the ArraySortedList<T> class, we will need to determine the smaller of two unequal elements of T. In particular, we cannot construct an ArraySortedList<StringLog>.
Java offers a cryptic header that says what we want.
Specifically, we can write
ArraySortedList<T extends Comparable<T>>
which says that any class plugged in for T must implement Comparable. We shall soon see that implementing Comparable means that we can tell which of two unequal elements is smaller.
Slightly more general and even more cryptic is
the header
ArraySortedList<T extends Comparable<? super T>>
I hope we will not need to use this.
Many classes define a compareTo() instance method taking one argument from the same class and returning an int. We say that x is smaller than y if x.compareTo(y)<0 and say that x is greater than y is x.compareTo(y)>0. Finally, it is normally true (and always for us) that x.compareTo(y)==0 if x.equals(y).
The Java library defines a Comparable interface, which includes just one method, compareTo(), as described above. Hence a class C implements Comparable if C defines compareTo() as desired. For such classes, we can decide which of two unequal members is smaller and thus these are exactly the classes T for which ArraySortedList<T> can be used.
More precisely, recent Java implementations (those with generics) define the Comparable<T> interface, where T specifies the class of objects that the given object can be compared to.
An example may help.
Many library classes (e.g., String)
implement Comparable<T>, where T is the
class itself.
Specifically the header for String states that
String implements Comparable<String>
This header says that the String instance method compareTo() takes a String argument.
Since String does implement Comparable (more precisely Comparable<String>), we can define ArraySortedList<String>.
StringLog does not implement Comparable at all; so we cannot write ArraySortedList<StringLog>.
Homework: 6.
As mentioned above the exact definition of list is not standardized. We shall follow the book's usage. One property of our lists is that each non-empty list has a unique first element and a unique last element (in a 1-element list the first and last elements are the same). Moreover the elements in a non-empty list have a linear relationship.
Definition: A set of elements has a Linear Relationship if each element except the first has a unique predecessor and each element except the last has a unique successor.
Lists can be
These assumptions are straight from the book
current position, the position of the next element accessed by getNext(). This position is incremented by getNext(), zeroed by reset(), and unchanged otherwise.
Start Lecture #17
We see below on the right the two interfaces for lists. The top interface applies to all lists, the bottom gives the additional methods available when the list is indexed.
In both cases elements are
equivalent if
the equals() method in T says so.
As always, when we say that such and such an object is returned, we mean that a reference to the object is returned
Just a few comments are needed as many of the methods are self-explanatory. The exception is the pair reset()/getNext(), which is discussed in a separate section by itself.
nicely formattedrepresentation of the list.
In an indexed list elements can be referred to by index (as in an array, a good model for such lists). Legal values for the index are 0..size()-1. All methods accepting an index throw an IndexOutOfBoundsException if given an illegal value.
Since elements have a linear relationship, it makes sense to talk of looping over the list from the first element to the last. The Java library has a super-slick and somewhat complicated mechanism to do this in an elegant manor (see the Iterable<T> interface, for details). We follow the book and define the following modest looping procedure.
All our List implementations keep track of the
current position of the list.
list.reset() for (int i=0; i<list.size(); i++) { element = list.getNext(); // play with element }
The code on the right shows a typical usage of these methods for a List named list. We use size() to iterate the correct number of times and use getNext() to advance to the next element.
As is often the case there are some technical details to mention. The easy detail is that, if getNext() is called when at the end of the list, the current position becomes the first element.
More interesting is what to do about empty lists and what happens
if we modify the list while
playing with an element.
Our solution is basically to say
Don't do that!.
The library permits some modifications, but for those not
permitted it also says
Don't do that!.
The requirements are that whenever list.getNext() is
called.
import ch06.lists.*; public class ListExamples { public static void main (String[] args) { ListInterface<String> list1 = new ArrayUnsortedList<String>(3); list1.add("Wirth"); list1.add("Dykstra"); list1.add("DePasquale"); list1.add("Dahl"); list1.add("Nygaard"); list1.remove("DePasquale"); System.out.print("Unsorted "); System.out.println(list1); ListInterface<String> list2 = new ArraySortedList<String>(3); list2.add("Wirth"); list2.add("Dykstra"); list2.add("DePasquale"); list2.add("Dahl"); list2.add("Nygaard"); list2.remove("DePasquale"); System.out.print("Sorted "); System.out.println(list2); IndexedListInterface<String> list3 = new ArrayIndexedList<String>(3); list3.add("Wirth"); list3.add("Dykstra"); list3.add("DePasquale"); list3.add("Dahl"); list3.add("Nygaard"); list3.remove("DePasquale"); System.out.print("Indexed "); System.out.println(list3); } }
This example, which I have taken from the book, illustrates well some differences between the three array-based implementations that we shall study. The first two ArrayUnsortedList and ArraySortedList each implement List; whereas, the third ArrayIndexedList implements IndexedList.
The main method has three sections, one for each list type. In all three cases the same 5 elements are added in the same order and the same element is is removed. The printed results, however, are different for the three cases. Not surprisingly the toPrint() in ArrayIndexedList includes index numbers, while the others do not.
The first surprise is that the output for ArrayUnsortedList does not print the items in the order they were inserted. This is due to the implementation of remove(). The example shown removes the third of the five previously entered elements. Naturally we don't want to leave a hole in slot three.
A natural solution would be to slide each element up so the old fourth becomes the third and the old fifth becomes the fourth. The problem with this solution is that if the first of N elements is deleted you would need to slide N-1 elements, which is O(N) work.
The chosen solution is to simply move the last element into the vacated slot. Remember that an unsorted list has no prescribed order of the elements.
The sorted list, list2, keeps the elements in sorted order. For Java String's the order is lexicographical. Consequently, removal does involve sliding up the elements below the one removed.
Finally, the ArrayIndexedList does not generate sorted lists so is again free to use the faster removal method. As mentioned above, this method enhances the output by generating a string version of the indices.
The result of these decisions is the output below, where I have reformatted the output into three columns so that more can be viewed on the screen
Unsorted List: Sorted List: Indexed List: Wirth Dahl [0] Wirth Dykstra Dykstra [1] Dykstra Nygaard Nygaard [2] Nygaard Dahl Wirth [3] Dahl
Homework: 13, 15.
A UML diagram for all the lists in this chapter is here.
The basic idea for an array-based list is simple: Keep the elements in array slots 0..(size-1), when there are size elements present. We increase size on inserts and deleted it on removals.
We shall meet a new visibility modifier in this section. The reason we can't make do with public and private is that we will be implementing two classes, one derived from the other. In this situation we want to give the derived class access to what would otherwise be private fields and methods of the base class.
More details will be given later when we implement the derived class.
package ch06.lists; public ArrayUnsortedList<T> implements ListInterface<T> { protect final int DEFCAP = 100; protected T[] list; protected int numElements = 0; protected int location; protected int currentPos; public ArrayUnsortedList() { list = (T[]) new Object[DEFCAP]; } public ArrayUnsortedList(int origCap) { list = (T[]) new Object[origCap]; }
Most of the code on the right is quite clear. For now, treat protected as private; the fields are not available to ordinary users of the class.
currentPos is use by the reset()/getNext() pair shown below.
Recall that a weakness in Java generics forbids the creation of a generic array, which explains the treatment of list.
Several of the public methods need to search for a given element. This task is given to an helper boolean method find() which, if the element is found, sets location for use by the public methods.
protected void enlarge() { T[] larger = (T[]) new Object[2*list.length]; for (int i=0; i<numElements; i++) larger[i] = list[i]; list = larger; } protected boolean find(T target); { for (location=0; location<numElements; location++) if (list[location].equals(target)) return true; return false; }
There are two helper methods.
The enlarge() method is called when an addition is
attempted on a currently
full list.
Recall that all the lists is this chapter are unbounded so
technically are never full.
Unlike the authors who raise the capacity by a fixed amount, I double it.
Then the current values are copied in.
The find() method implements a standard linear search. The only point to note is that the index used is a field and thus available to the public methods that call find().
The authors define a void find() and define a field (found) to hold the status of the search. I prefer a boolean find().
public void add(T element) { if (numElements == list.length) enlarge(); list[numElements++] = element; public boolean remove(T element) { if (!find(element)) return false; list[location] = list[--numElements]; list[numElements] = null; return true; } public int size() { return numElements; } public boolean contains(T element) { return find(element); } public T get(T element) { if (find(element)) return list[location] return null; } public String toString() { String str = "List:\n"; for (int i=0; i<numElements; i++) str = str + " " + list[i] + "\n"; return str; }
The add() method works as expected. For an unsorted list, we are free to add the new element anywhere we wish. It is easiest to add it at the end, so we do so.
Since our lists are unbounded, we must enlarge() the array if necessary.
The remove() method uses find() to determine if the desired element is present and if so where it is located (recall that find() sets location).
Removes can occur at any slot and we cannot leave a hole in the middle. Again we take the easy way out and simply move the last element into the hole.
Does this work if the element was found in highest array
slot?
Answer: Let's try it in class.
The size() method is trivial.
The contains() method is easy given the helper find().
The get() method, like remove() uses find() to determine the location of the desired element, which get() then returns. If find() reports that the element is not present, get() returns null as per its specification.
The toString() method, constructs its return value one line at a time, beginning with a header line and then one line for each listed element.
public void reset() { currentPos = 0; } public T getNext() { T next = list[currentPos++]; if (++currentPos == numElements) currentPos = 0; return next; }
As mentioned previously reset() and getNext() are use to enable looping through a the elements of the list. The idea is that currentPos indicates the next site to access and that getNext() does the access.
The reset() method initializes the
loop by
setting currentPos to zero.
These methods are easy because we forbid the user to mess up the list and do not check whether they do.
Now we want to keep the listed items in sorted order. But this might not even make sense!
I certainly understand a sorted list of Integer's or a sorted list of String's. But a sorted list of blueprints? Or bookcases?
That is, a sorted list of T's makes sense for some T's, but not for others. Specifically, we need that the objects in T can be compared to determine which one comes first.
Java has exactly this concept; it is the Comparable interface. So, we want to require that T implements this interface, which leads to two questions.
public class ArraySortedList<T> implements ListInterface<T>
Our first attempt at a header line for the ArraySortedList class, before considering Comparable but remembering that the class must implement ListInterface<T>, would be something like we see on the right.
public class ArraySortedList<T implements Comparable> implements ListInterface<T> public class ArraySortedList<T extends Comparable> implements ListInterface<T>
When trying to add the restriction that T implement Comparable, my first guess would be the top header on the right. However, that header is wrong; instead of implements we use the keyword extends, which gives the correct bottom header line. I am not certain of the reason for this choice of keyword, but an indication is below.
This last header is legal Java and illustrates how one limits the classes that can be plugged in for T. It is not perfect, however. We shall improve it after first learning how to use Comparable and thereby answering our second question above.
Objects in a class implementing the Comparable interface are ordered. Given two unequal objects, one is less than the other. This interface specifies only one instance method, compareTo(), which has one parameter and returns an int result.
The invocation x.compareTo(y) returns a negative integer, zero, or a positive integer to signify that x is less than, equal to, or greater than y.
The description just above, which did not
mention T, would have been applicable a few years ago and
probably still
works today.
However, modern, generics aware, Java specifies a
generic Comparable<T> interface.
On the right we see proper specifications of classes implementing Comparable.
public class C implements Comparable<C> public class String implements Comparable<String> public class C implements Comparable<D>
The first line asserts that an object in C can be compared
to another object in C.
The second line shows (part of) the header line for the familiar class String.
The third line asserts that an object in C can be compared to an object in D.
public class ArraySortedList<T extends Comparable<T>> implements ListInterface<T>
On the right we see a proper header for ArraySortedList<T> specifying that the class parameter T must implement Comparable<T>.
In fact the
best header we could write
for ArraySortedList would be
ArraySortedList<T extends Comparable<? super T>> implements ListInterface<T>
What this cryptic header is saying is
that instead of requiring that elements
of T can be compared with other
elements of T, we require that
elements of T can be compared with
elements of some superclass of T.
The ? in the header is
a
wildcard.
Note that T itself is considered a
superclass of T.
Since T extends a superclass
of T, perhaps this explains the choice
of the keyword extends above.
Why all this fuss about Comparable and fancy headings? We must do something since we need to keep the entries of our sorted list ordered. In particular, the add() method must place the new entry in the correct location (and slide the rest down).
The book uses the very first ArraySortedList header line that we considered. Recall that this header did not mention Comparable at all. What gain do we get for our efforts?
public class ArraySortedList<T> implements ListInterface<T> public class ArraySortedList<T extends Comparable<T>> implements ListInterface<T>
For convenience, both headers are repeated on the right.
Since the first header does not mention Comparable, a simple use of compareTo() for elements would fail to compile since there is no reason to believe that T contains such a method. Hence to find the correct location for add() to place the new element, the book compares this new element with existing elements using the following if statement
if (((Comparable)listElement).compareTo(element) < 0) // list element < add element
I would rate this if statement as roughly equal to our header on the ugliness scale, so using our header to simplify the if statement would be only a wash, not an improvement.
The real advantage of our approach is that the ugly if statement generates a warning from the compiler that it cannot guarantee that the listElement object contains a compareTo() method. This warning is quite appropriate since there is nothing to suggest that listElement, a member of T, is comparable to anything.
With our header the if statement becomes the expected
if (listElement.compareTo(element) < 0) // list element < add element
and, more significantly, generates no warning. As a result we cannot get a runtime error due to an inappropriate class being substituted for T.
We are now in a position to implement ArraySortedList<T> and could do so directly. However, we notice that the only methods that change between ArraySortedList<T> and ArrayUnsortedList<T> are add() (we need to insert the new item in the right place) and remove() (we must slide elements up instead of just placing the last element in the vacated slot). It seems a little silly to rewrite all the other methods so we choose to implement ArraySortedList<T> as an extension of ArrayUnsortedList<T>.
public class ArraySortedList<T extends Comparable<T>> extends ArrayUnsortedList<T> implements ListInterface<T> { ArraySortedList() { super(); } ArraySortedList(int origCap) { super(origCap); } public void add(T element) { int location; if (numElements == list.length) enlarge(); for (location=0; location<numElements; location++) if ((list[location]).compareTo(element) >= 0) break; for (int index=numElements; index>location; index--) list[index] = list[index-1]; list[location] = element; numElements++; } public boolean remove(T element) { boolean found = find(element); if (found) { for (int i=location; i<=numElements-2; i++) list[i] = list[i+1]; list[--numElements] = null; return found; } }
The header is a mouthful and conveys considerable information: this generic class requires the argument class to support comparison, inherits from the unsorted list, and satisfies the list specification. The constructors are the same as for the parent (ArrayUnsortedList<T>).
Since this is an unbounded implementation, we first enlarge the list if it is filled to capacity. Next we determine the correct location to use, which is the first location whose occupant is greater than or equal to the new element. To make room for the new element, we shift the existing elements from here on. Finally, we insert the new element and increase the count.
Since we must maintain the ordering, remove is simple. If the item is found, shift down all element from the found location on (thus overwriting the item) and reduce the count. Finally, return whether the item was present.
by Copyor
by Reference
Our list (and stack, and queue) implementations, when given an
element to insert, place (a reference to) the actual object on the
list.
This implementation is referred to as
by reference and, I
believe, is normally desirable.
But putting (a reference to) the actual object on the list can break the list's semantics since this listed object can be changed by the user. For example, the items in ArraySortedList<Integer> can become out of order, if a listed Integer is changed.
This problem can be avoided by having the add() method
make a copy of the item and then insert (a reference to) this
private copy rather than the user-accessible original.
This implementation is referred to as
by copy and requires
extra computation and extra memory when compared to
by
reference.
This extended class supports indexed references. In a sense it permits the user to treat the list as intelligent arrays. The two extensions to ArrayUnsortedList<T> class is to give an additional (indexed based) signatures to existing methods and introduce methods that require indices.
For example, in addition to add(T element), which just promises to add the element somewhere, the indexed list introduces add(int index, T element), which adds the element at the specified index.
New methods such as set(), which updates a specified location, have no analogue without indices.
The methods including an index parameter check the parameters for legality and throw a standard IndexOutOfBoundsException exception if needed.
package ch06.lists; public class ArrayIndexedList<T> extends ArrayUnsortedList<T> implements IndexedListInterface<T> { public ArrayIndexList() { super(); } public ArrayIndexList(int origCap) {super(origCap); } public void add(int index, T element) { if ((index<0) || (index>numElements)) throw new IndexOutOfBounds Exception("Helpful message."); if (numElements == list.length) enlarge(); for (int i=numElements; i>index; i--) list[i] = list[i-1]; list[index] = element; numElements++ } public T set(int index, T element) { if ((index<0) || (index>numElements)) throw new IndexOutOfBounds Exception("Helpful message."); T hold = list[index]; list[index] = element; return hold; } public int indexOf(T element) { if (find(element)) return location; return -1; } public T remove (int index) { if ((index<0) || (index>numElements)) throw new IndexOutOfBounds Exception("Helpful message."); T hold = list[index]; for (int i=index; i<(numElements-1); i++) list[i] = list[i-1]; list[numElements--] = null; return hold; public String toString() { String str = :List:\n"; for (int i=0; i<numElements; i++) str = str + "[" + i "] " + list[i] + "\n"; return str;
No surprises here. The list is not sorted so doesn't involve Comparable
After checking the index for legality, the method enlarges the array if necessary.
Since the goal is to place the new element in a specified slot, add() next shifts down the existing elements from the desired slot on. Note that this loop runs backwards.
This method sets the specified slot to the given element and returns the former occupant. The code is straightforward
This simple method returns the index of a sought for element or -1 if the element is not on the list.
This method removes and returns the element in a specified slot. The code is again straightforward.
The only difference between this method and one being overridden is the addition of the index value within brackets.
Homework: 18, 21.
Start Lecture #18
Remarks:)
Lab 4 had confusing words for a few days so I am extending the due date until 17 November 2012.
Read.
A crucial advantage of sorted lists is that searching is faster. No one would use a telephone directory with the names unsorted.
The linear search algorithm, which we have already seen, is given a list and a desired value. The algorithm can be described as follows.
We can improve this algorithm (a little) by recognizing that if the current list value exceeds the desired value, the desired value is not present. That is the algorithm becomes the following (assuming the list is sorted in ascending order).
In comparison, the binary search algorithm can be described as follows (again assuming the list is sorted in ascending order).
halfof the list; otherwise, search only the lower
half.
My presentation differs in three small ways from the book's.
Since our goal is to write a drop-in replacement for the find() method in ArraySortedList<T>, our header line must be the same as the one we are replacing. Recall that the value returned by find() indicates whether the search was successful. If successful the location instance data field is set. Our replacement must have the same semantics.
protected boolean find(T target)
The required header is shown on the right. (In fact there is no find() method in the code for ArraySortedList<T>; instead it is inherited from ArrayUnsortedList<T>).
The original (linear search) find() searched the entire occupied portion of the array; whereas the binary search algorithm searches smaller and smaller sub-arrays with each recursive call. Thus, we shall need to specify the current lower and upper bounds for the search.
protected boolean find(T target) { return find1(target, 0, numElements-1); }
Hence we will need a helper method find1() that accepts these extra parameters and performs the real search. The find() method itself is the trivial routine on the right. It simply passes the job onto find1() telling it to search the entire range of possible values.
private boolean find1(T target, int lo, int hi) { if (lo > hi) return false; int location = (lo + hi) / 2; if (list[location].compareTo(target) == 0) return true; if (list[location].compareTo(target) < 0) return find1(target, location+1, hi); return find1(target, lo, location-1); }
Perhaps the only subtlety in this method is the first base case, which is represented by the first if statement on the right. When we have reduced the range of interest to the empty set, the item is definitely not present.
The rest of the method is essentially an English-to-Java
translation of the words above describing the algorithm.
If the middle location contains the target, we are done; if it is
less search the upper
half; otherwise search the lower
half.
Notice that find1() is tail-recursive, that is the two
recursive calls are each the last statement executed.
Question: How can two different calls each be the last statement?
Answer: Last doesn't mean the last one written, it means the last one executed.
As we noted before, tail recursive methods can be converted to iterative form fairly easily.
protected boolean find(T target) { int lo=0, hi=numElements-1; while (lo <= hi) { location = (lo + hi) / 2; if (list[location].compareTo(target) == 0) return true; if (list[location].compartTo(tartet)) lo=location+1; else hi=location-1; } return false; }
In fact the code on the right is essentially the same as the pair above it.
The difference is that instead of a recursive call we just go back to the beginning. The jumping to the beginning and a recursive call start out the same. But when the recursion ends, we normally have more to do in the caller. However, this is tail-recursion so there is nothing more to do.
Lets go through a few searches and see.
How much effort is required to search a list with N items?
For linear search the analysis is easy, but the result is bad.
If we are lucky, the element is found on the first check. If we are unlucky, the element is found at the end of the list or not at all. In these bad cases we check all N list elements. So the best case complexity of linear search is O(1) and the worst case complexity is O(N).
On the average we will find the element (assuming it is present) in the middle of the list with complexity O(N/2)=O(N).
The worst case is still O(N). For example consider searching for an element larger than every listed element.
In binary search, each update of lo or hi reduces the range of interest to no more than half what it was previously. This occurs each iteration or each recursive call, which leads to two questions.
The first question is easy, each iteration and each recursive call, does an amount of work bounded independent of N. So each iteration or recursive call is O(1).
The second question might be easier looked at in reverse. How many times must you multiply 2 by itself to reach at least N? That number is log2(N), which we write as simply log(N) since, by default, in this class logs are base 2. Hence the complexity is O(log(N)), a big improvement. Remember that log(1,000,000,000)<30.
Homework: 42.
We now give linked implementations of both unsorted and sorted
lists.
However, we do not implement a linked, indexed list (even though we
could).
Why not?
Answer: Accessing the linked item at index i requires traversing the list. Thus the operation has complexity O(N) where O(N) is the current size of the list.
This answer illustrates a strong advantage of array-based lists, to balance against the disadvantage of having to enlarge() them or deal with them being full.
As with stacks and queues, reference based lists use the LLNode<T> class.
The UML for all our lists is here. (References to all UMLs are repeated at the end of the notes.)
The authors choose to say Ref rather than Linked since the latter is used by the standard Java library.
package ch06.lists; import support.LLNode; public class RefUnsortedList<T> implements ListInterface<T> { protected int numElements = 0; protected LLNode<T> currentPos = null; protected LLNode<T> location; protected LLNode<T> previous; protected LLNode<T> list = null;
As with the array-based implementation we use an ugly header to avoid an ugly and unsafe if statement found in the book.
The currentPos field is used with the reset()/getNext() pair describe below.
We shall see that removing an item from a given location requires referencing the previous location as well.
Finally, list references the first node on the list (or is null if the list is empty).
These fields are illustrated in the diagram on the right, which shows a list with 5 elements ready for the next-to-last to be remove()'d. reset() has been called so getNext() would begin with the first node (assuming the remove() did not occur).
The default no-arg constructor suffices so no constructor is written.
Homework: 47a, 47b (use the diagram style used on the midterm), 50.
public void add(T element) { LLNode<T> newNode = new LLNode<T>(element); newNode.setLink(list); // new becomes first list = newNode; numElements++; }
Since the list is not sorted we can add elements wherever it is
most convenient and for a single linked list, that is at the front
(i.e., right
after the RefUnsortedList<T>
node itself).
public int size() { return numElements; }
Since we explicitly maintain a count of the number of elements currently residing on the list, size() is trivial.
public boolean contains(T element) { return find(element); } protected boolean find(T target) { location = list; while (location != null) if (location.getInfo().equals(target)) return true previous = location; location = location.getLink(); return false; }
As in the array-based implementations we use a predicate find() instead of a found data field.
You may notice that extra work is performed while searching for an element. This is done so that, after find() is executed the found element is ready for removal.
Note the efficient technique used to determine the actual location and its predecessor (the latter is needed for removal). Thus the superfluous work just mentioned is small.
The workhorse find() is protected so that derived classes (in particular, RefSortedList, to be studied next) can use it.
The natural technique to remove a target element from a linked list is to make the element before the target point to the element after the target.
This is shown on the right, where the middle node is the target.
public boolean remove(T element) { boolean found = find(element); if (found) { if (location = list) // first element list = location.getLink(); else previous.setlink(location.getLink()); numElements--; } return found; }
The only tricky part occurs when the target is first element since there is then is no element before the target. The solution in this case depends on the details of the implementation.
In our implementation, the list field acts as the (link component of the) element before the first element. Hence, the code on the right makes list point at the element after the target when target is the first element.
Start Lecture #19
Remark: The RefUnsortedList<T> header does not need to mention Comparable as I guessed last time. It is fixed now.
public T get(T element) { if find(element) return location.getInfo(); else return null; }
Whereas the contains() predicate merely determines whether a given element can be found on the list, get() actually returns a reference to the element. As expected, find() again does all the work.
The only question is what to do if the element cannot be found; we specify that null be returned in that case.
public void reset() { currentPos = list; } public T getNext() { T next = currentPos.getInfo(); if (currentPos.getLink() == null) currentPos = list; else currentPos = currentPos.getLink(); return next; } } // end of class RefUnsortedList<T>
To employ this pair, the user calls reset() to get started and then calls getNext() repeatedly to retrieve successive elements on the list.
It is not hard to think of difficult cases to implement and hence the code on the right seems surprisingly simple. The simplicity is due to the difficult cases being outlawed and not checked for. For example, an empty list gives a null pointer exception when getNext() executes it first instruction.
Specifically, the implementation assumes that when getNext() is invoked:
We shall see next chapter that reset()/getNext() can be applied to some structures that are not lists (we will do binary trees).
There is not much difference between the RefUnsortedList<T> and RefSortedList<T> classes; almost all the methods remain the same. For this reason, we implement the latter as an extension of the former.
One difference between the classes is that now that we want the elements to be in order, we must require that T implement Comparable<T>.
public class RefSortedList<T extends Comparable<T>> extends RefUnsortedList<T> implements ListInterface<T> {
The header shows the dependence on RefUnsortedList<T>. There are no fields beyond those of the base class and again the default no-arg constructor suffices. Note that this constructor invokes the superclass constructor.
The one method we do need to change is add(). Previously we chose to insert the new element at the beginning of the list because that was the easiest place. Now we must skip over all existing elements that are smaller than the one we are inserting.
Once we have found the correct location, the insertion proceeds as illustrated on the right. The new node, shown on the bottom row, is to be inserted between the first two nodes on the top row. These nodes are called prevLoc and location in the code below. The former is the last node we skipped over in seeking the insertion site and the latter is thus the first node not skipped.
public void add(T element) { LLNode<T> prevLoc = null; LLNode<T> location = list; while (location!=null && location.getInfo().compareTo(element)<0) { prevLoc = location; location = location.getLink(); } LLNode<T> newNode = new LLNoDE<T>(element); if (prevLoc == null) { // add at front of list newNode.setLink(list); list = newNode; } else { // add elsewhere newNode.setLink(location); prevLoc.setLink(newNode); } numElements++; } } // end of class RefSortedList<T>
The method begins with a short but clever search loop to find the
two nodes between which the new node is to be inserted.
This loop is similar to the one in find() and deserves
careful study.
Questions How come .getInfo() does not ever raise a nullPointerException.
How come location.getInfo() will have a compareTo() method defined.
Answers: Short circuit evaluation of &&.
T implements Comparable<T>.
After the loop, we create and insert the new node. The then arm is for insertion at the beginning (done identically to the method in RefUnsortedList<T>); the else arm is for insertion between preLoc and Location.
Finally, we increase the count of elements.
Homework: 47c, 47d, 48.
For practice in the programming technique just illustrated, let's do on the board the problem of finding the second largest element in an array of int's.
A solution is here.
Previously we have studied stacks, a linear structure in which all activity occurs at one end (the top), and queue another linear structure, in which activity occurs at both ends (the front and rear). In this chapter we studied lists, general linear structures in which activity can occur throughout.
We also encountered our first high performance algorithm, binary search, which improves complexity from O(N) for naive searching down to O(logN).
If we use an array-based list, we can employ binary search, which speeds up retrieval from O(N) to O(logN)). However, these lists are not as convenient when the list size is static.
We shall see that binary search trees combine the advantages of O(logN) searching with linked-like memory management.
A key characteristic of lists is their linear structure: Each node (except for the first and last) has a unique predecessor and a unique successor.
Tree nodes, in contrast, have (zero or more) children and (zero or one) parents. As in biology, if A is a child of B, then B is the parent of A. Most nodes do have a parent; the one exception is the tree root, which has no parent. The root can be reached from any other node by repeated moving to the parent.
Nodes that have no children are called leaves of the tree. Other nodes are called interior.
We see two small trees on the right.
Note that there is a specific direction inherent in a tree diagram, from root to leaves. In the bottom diagram the direction is shown explicitly with arrowheads; in the top diagram it is implicitly going from top to bottom.
Trees are often used to represent hierarchies.
For example this chapter can be viewed as tree.
The root is
Chapter 8 Binary Search Trees.
This root has 11 children
8.1 Trees ... 8.10
Case Study: Word Frequency Generator,
Summary.
The node
8.2 The Logical Level has two children
Tree Elements and
The Binary Search Tree Specification.
In fact this chapter can be considered as a subtree of the entire
tree of the book.
That bigger tree has as root
Object-Oriented Data Structures Using Java.
Each chapter
heading is a child of this root and each chapter itself is a subtree
of the big tree.
The two diagrams on the right show graphs that are not trees. The graph on the near right is not a tree since the bottom node has two parents. The graph on the far right, does not have a single root from which all nodes are descendants.
We often think of the tree as divided into horizontal levels. The root is at level 0, and the children of a level n node are at level n+1.
Some authors, but not ours, also use the term depth as a synonym for level.
Unlike level (and depth) which are defined from the root down, height is defined from leaves up. The height of a leaf is 0 and the height of an interior node is one plus the maximum height of its children.
The height of a tree is the height of its root, which equals the maximum level of a node.
For any node A, the subtree (rooted) at A consists of A plus A's children, plus their children, plus their children, ... .
The nodes constituting the subtree at A excluding A itself are called the descendants of A.
If a node X is a descendant of Y, we also say that Y is an ancestor of X.
Two nodes with the same parent are called siblings
Illustrate all these definitions on the board
Trees are quite useful in general. However, in this course, we will mostly use trees to speed-up searches and will emphasize a subclass of trees, binary search trees (other trees are used for searching, but we will not be studying them).
Definition: A binary tree is a tree in which no node has more than two children
For example the tree on the right is a binary tree.
We distinguish the right and left child of a node. For example the node H on the right has only a left child, the node I has only a right child, and the root has both a left and right child.
We also talk of the right and left subtrees of a node. The right subtree is the subtree rooted at the right child (assuming the node has a right child; otherwise the right subtree is empty) and similarly for the left subtree.
We will see that most of our operations will go up and down trees once or a few times and will not normally move from sibling to sibling. Thus these operations will take time proportional to the height and therefore low-height binary trees are preferable.
Consider all possible binary trees with 15 nodes. What are the maximum and minimum possible heights?
The max is pretty easy: a line. That is 14 nodes with one child and one leaf at the end. These trees have height 14.
The min is not too hard either. We want as many nodes as possible with 2 children so that the tree will be wide, not high. In particular, the minimum height tree has 7 interior nodes (each with 2 children) on the top three levels and 8 leaves on level 3. Its height is 3.
The same reasoning as above shows that the maximum height is 1048574 and the minimum is 19. Quite a dramatic difference. Note that a million nodes is not unreasonable at all. Consider, for example, the Manhattan phone book.
If all the interior nodes have two children, then increasing the height by 1, essentially doubles the number of nodes. Said in reverse, we see that the minimum height of a tree with N nodes is O(logN).
Thus the possible heights range from O(logN) to O(N).
Homework: 1, 2, 3, 4.
Consider the bushy 15-node binary tree shown in the diagram above. It has height 3. Assume each node contains a value and we want to determine if a specific value is present.
If that is all we know, we must look at every node to determine that a value is not present, and on average must look at about 1/2 the nodes to find an element that is present. No good.
The key is to an effective structure is that we don't place the values at random points in the tree. Instead, we place a value in the root and then place all values less that this root value in the left subtree and all values greater than the root value in the right subtree.
Recursively we do this for all nodes of the tree (smaller values on the left; larger on the right).
Doesn't work. How do we know that exactly 7 of the values will be less than the value in the root? We don't.
One solution is to not pick the shape of the tree in advance. Start with just the root and, place the first value there. From then on, take another value and create a new node for it. There is only one place this node can be (assuming no duplicate values) and satisfy the crucial binary search tree property:
The values in the left subtree are less than or equal to the value in the node, and the values in the right subtree are greater than or equal to the value in the node.
Definition:A binary search tree is a binary tree having the binary search tree property.
Although a binary search does not look like a sorted list, we shall see that the user interfaces are similar.
Start Lecture #20
Remarks
while unvisited nodes remain pick an unvisited node visit that node inorderTraversal(Node N) if (N has a left child) preorderTraversal(left child) visit(N) if (N has a right child) preorderTraversal(right child) preorderTraversal(Node N) visit(N) if (N has a left child) preorderTraversal(left child) if (N has a right child) preorderTraversal(right child) postorderTraversal(Node N) if (N has a left child) preorderTraversal(left child) if (N has a right child) preorderTraversal(right child) visit(N) inorderTraversal(Node N) if (N is not null) preorderTraversal(left child) visit(N) preorderTraversal(right child) preorderTraversal(Node N) if (N is not null) visit(N) preorderTraversal(left child) preorderTraversal(right child) postorderTraversal(Node N) if (N is not null) preorderTraversal(left child) preorderTraversal(right child) visit(N)
Traversing a binary tree means to visit each node of the tree in a specified order. The high-level pseudo code is on the right. The difference between traversals is the order in which the nodes are picked for visitation.
We shall study three traversals, preorder, inorder, and postorder, whose names specify the relative order of visiting a node and its children.
All three traversals are shown on the right in two styles (see below).
As you can see all three traversals have the same statements and all three traverse left subtrees prior to traversing the corresponding right subtrees.
The difference between the traversals is where you place visit(N) relative to the two subtree traversals.
In the first implementation style we do not recurse if a child is null; in the second we do recurse but return right away. Although the second seems silly, it does handle the case of an empty tree gracefully. Another advantage is that it makes the base case (an empty tree) clear.
We shall see right away that when preforming an inorder traversal of a binary search tree, the values of the nodes are visited in order, i.e., from smallest to largest.
Let's do on the board a few traversals of both ordinary binary trees and binary search trees.
Homework: 5,6,9,10.
Discussion of Comparable<T>, which we did already.
We make the following choices for trees, which are consistent with the choices we made for lists.
In addition the methods do not support null arguments and do not check this condition
The UML diagram for the interface is shown on the right. It is quite similar to the equivalent diagram for sorted lists.
The main differences between the interfaces for BSTs and for sorted lists occur in the specification of the reset()/getNext() pair. We parameterize reset() so that the pair can traverse the tree in either preorder, inorder, or postorder. Specifically, we define the following three Java constants.
public static final int INORDER = 1; public static final int PREORDER = 2; public static final int POSTORDER = 3;
In addition, we enhance reset() to return the current size of the tree for so that a user of the pair know how many time to invoke getNext().
Read. The authors re-implement the golf application using binary search trees instead of sorted lists, which illustrates how little changes from the user's viewpoint.
The first order of business is to define the class representing a
node of the tree.
Question: Why can't we reuse LLNode<T>?
Answer: Those nodes have only one reference to another node (the successor). For binary trees we need two such references, on to the left child and one to the right child.
A detailed picture is on the right.
This node would work fine for any binary tree. That is, it has no dependence on the binary search tree property.
The node would not work for arbitrary trees since it contains references to only two children.
Diagrams of full tree-like structures typically do not show all the Java details in the picture above. Instead, each node would just be three boxes, two containing references to other nodes and the third containing the actual data found in the element. A simplified diagram of a 3-node structure is shown on the right.
Although these simplified diagrams are unquestionably useful, please do not forget the reference semantics that is needed for successfully implementing the concepts in Java.
Question: What would be a good node for an
arbitrary (i.e., non-binary) tree?
Answer: One possibility is to have (in addition to info) an array of children. Let's draw it on the board.
Another possibly would be to have two references one to the leftmost child and the other to the
closest right sibling.
Draw a tree on the board using the normal style and again using the
left-child/right-sibling style.
package support; public class BSTNode<T extends Comparable<T>> { private T info; private BSTNode<T> left = null; private BSTNode<T> right = null; BSTNode(T info) { this.info = info; } public T getInfo() { return info; } public void setInfo(T info) { this.info = info; } public BSTNode<T> getLeft() { return left; } public void setLeft(BSTNode<T> link) { left = link; } public BSTNode<T> getRight() { return right; } public void setRight(BSTNode<T> link) { right = link; } }
The BSTNode<T extends Comparable<T>> implementation is shown on the right. It is straightforward.
To construct a node you supply (a reference to) info and the resulting node has both left and right set to null.
There is a set and a get method for each of the three fields: info, left and right.
(The book chooses to have the constructor explicitly set left and right to null; I prefer to accomplish this via an initialization in the declaration.
A full UML diagram for BSTs is here and at the end of these notes.
package ch08.trees; import ch03.stacks.*; // used for iterative size() import cho4.queues.* // used for traversals import support.BSTNode; public class BinarySearchTree<T extends Comparable<T>> { private BSTNode<T root = null; private found; // used by remove() private LinkUnbndQueue<T> BSTQueue; private LinkUnbndQueue<T> preOrderQueue; private LinkUnbndQueue<T> postOrderQueue; public boolean isEmpty() { return root == null; } public int size() { return recSize(root); } // rest later } // end of BinarySearchTree<T>
This class will require some effort to implement. The linear nature of stacks, queues, and lists make them easier than trees. In particular removing an element will be seen to be tricky.
The very beginning of the implementation is shown on the right. The only field is root. For an empty tree, which the initial state of a new tree, root is null. Otherwise it references the BSTNode<T> corresponding to the root node.
isEmpty() is trivial, but the rest is not.
The public method size() simply calls the helper recSize(), which is in the next section.
private int recSize(BSTNode<T> tree) { if (tree == null) return 0; return recSize(tree.getLeft()) + recSize(tree.getRight()) + 1; }
The book presents several more complicated approaches before the one shown on the right. The key points to remember are.
Much harder. In some sense you are doing the compiler's job of transforming the recursion to iteration.
In this case, and often with trees, it is no contest: recursion is much more natural and consequentially much easier.
Homework: 20.
Homework: How do you find the maximum element in a binary search tree? The minimum element?
public boolean contains(T element) { recContains(element, root); } private boolean recContains(T element, BSTNode<T> tree) { if (tree == null) return false; if (element.compareTo(tree.getInfo()) == 0) return true; if (element.compareTo(tree.getInfo()) < 0) return recContains(element, root.getLeft()); return recContains(element, root.getRight()); } public T get(T element) { return recGet(element, root); } public T recGet(T element, BSTNode<T> tree) { if (tree == null) return null; if (element.compareTo(tree.getInfo()) == 0) return tree.getInfo(); if (element.compareTo(tree.getInfo()) < 0) return recGet(element, root.getLeft()); return recGet(element, root.getRight()); }
The public contains() method simply calls the private helper asking it to search starting at the root.
The helper first checks the current node for the two base cases: If we have exhausted the path down the tree, the element is not present. If we have a match with the current node, we found the element.
If neither base case occurs, we must proceed down to a subtree, the comparison between the current node and the target indicates which child to move to.
get() is quite similar to contains(). The difference is that instead of returning true or false to indicate whether the item is present or not, get() returns (a reference to) the found element or null respectively.
Homework: 31.
The basic idea is straightforward, but the implementation is a little clever. For the moment ignore duplicates, then addition proceeds as follows.
Start searching for the item, this will force you down the tree, heading left or right based on whether the new element is smaller or larger than (the info component of) the current node. Since the element is not in the tree, you will eventually be asked to follow a null pointer. At this point, you create a new node with the given element as info and change the null pointer to reference this new node.
What about duplicates?
Unlike a real search, we do not test if the new element equals (the info component of) each node. Instead, we just check if the new element is smaller. We move left if it is and move right if it isn't. So a duplicate element will be added to the right.
Although add() is short and the basic idea is simple, the implementation is clever and we need to study it on examples. As described above, we descend the tree in the directions determined by the binary search tree property until we reach a null pointer, at which point we insert the element.
public void add(T element) { root = recAdd(element, root); } private BSTNode<T> recAdd(T element, BSTNode<T> tree) { if (tree == null) // insert new node here tree = new BSTNode<T>(element); else if (element.compareTo(tree.getInfo()) < 0) tree.setLeft(recAdd(element, tree.getLeft())); else tree.setRight(recAdd(element, tree.getRight())); return tree; }
The clever part is the technique used to change the null pointer to refer to the new node. At the deepest recursive level, the setLeft() or setRight() does set a null pointer to a pointer to the new leaf. At other levels it sets a field to the value it already has. This seems silly, but determining when we are making the deepest call (i.e., when the assignment is not redundant) is harder and might cost more than doing the assignment.
Do several examples on the board. Start with an empty tree and keep adding elements.
Then do it again adding the elements in a different order. The shape of the resulting tree depends strongly on the order the elements are added.
Homework: 29, 33.
Start Lecture #21
Remark: Should show that adding the same values in different orders can give very different shaped BSTs.
Whereas the basic idea for add() was clear (the implementation was not); for remove() we first must figure out what to do before we can worry about how to do it.
If the node to be removed is a leaf, then the result is clear: toss the node and change its parent to refer to null.
A minor problem occurs when the leaf to be removed is also the root of the tree (so the tree has only one node). In this case, there is no parent, but we simply make the root data field null, which indicates that the tree is empty. In a rough sense, the root data field acts as the parent of the root node.
The real problem occurs when the node to be removed is not a leaf, especially if it has two children.
If it has one child, we make the child take the place of its to-be-removed parent. This is illustrated on the right where the node containing H is to be removed. H has one child, M, which, after the removal, has the tree position formerly held by H. To accomplish this removal, we need to change the pointer in H's parent to refer instead to M.
The triangles in the diagram indicate arbitrary (possibly empty) subtrees. When removing a node with one parent all the subtrees remained connected to the same nodes before and after the operation. For some algorithms, however, (in particular for balancing an AVL tree, which we may not study), the subtrees move around.
The dots in the upper right indicate that D may not be the root of the tree. Although the diagram suggests D is a right child, this is not implied. D could be the root, a right child, or a left child.
As mentioned this is the hardest case. The goal is to remove node H, which has two children. The diagram shows the procedure used to reduce this case to the ones we solved before, namely removing a node with fewer than 2 children.
The first step is to find H's predecessor, i.e. the node that comes right before H in sorted order. To do this we go left then go as far right as possible arriving at a node G, which definitely has no right child.
The key observation is that if we copy the info from this node to the node we wish to remove, we still have a binary search tree. Since G is before H, any node greater than H is greater than G. Since G is immediately before H, any other node less than H is less than G. Taken together these two fact show that the binary search property still holds.
Now we must remove the original G node. But this node has no right child so the situation is one we already have solved.
public boolean remove (T element) { root = recRemove(element, root); return found; }
Now that we know what to do, it remains to figure out how to do it. As with node addition, we have a simple public method, shown on the right, that implements the announced specification, and a private helper that does most of the work.
The helper method is assigned two tasks. It sets the data field found, which the public method returns, and the helper itself returns (a reference to) the root of the tree it is given, which the public method assigns to the corresponding data field.
In most cases the root of the original tree doesn't change; however, it can change when the element being removed is located in the root. Moreover, the helper calls itself and when a value is removed the parent's left or right pointer is changed accordingly.
private BSTNode<T> recRemove(T element, BSTNode<T> tree) { if (tree == null) { // element not in tree found = false; return tree; } if (element.compareTo(tree.getInfo()) == 0) { found = true; // found the element return removeNode(tree); } if (element.compareTo(tree.getInfo()) < 0) tree.setLeft(recRemove(element, tree.getLeft())) else tree.setRight(recRemove(element, tree.getRight())) return tree; }
The helper begins with the two base cases. If the tree parameter is null, the element is not present.
If the tree node contains the element we call removeNode() (described below).
In other cases we recursively descend the tree to the left or right depending on the comparison of element and the current node's info. We set the left or right field of the current node to the value of the recursive call. This cleverly assures that the parent of a deleted node has the appropriate field nulled out.
private BSTNode<T> removeNode (BSTNode<T> tree) { if (tree.getLeft() == null) return tree.getRight(); if (tree.getRight() == null) return tree.getLeft(); T data = getPredecessorInfo(tree); tree.setInfo(data); tree.setLeft(recRemove(data, tree.getLeft())); return tree; } private T getPredcessorInfo(BSTNode<T> tree) { tree = getLeft(tree); while (tree.getRight() != null) tree = tree.getRight(); return tree.getInfo(); }
We are given a node to remove and must return (a reference to) the node that should replace it (as the left or right child of the parent or the root of the entire tree).
As usual we start with the base cases, which occur when the node does not have two children. Then we return the non-null child, or null if both children are null.
If the node has two children we proceed as described above. First copy the info from the predecessor to this node and then delete the (actually a) node that contained this data. In this case the reference returned is the unchanged reference to tree.
Subtle, very subtle. It takes study to see when links are actually changed.
Trace through some examples on the board.
Homework: 36,37.
As we have seen in every diagram, trees do not look like lists. However, the user interface we present for trees is quite similar to the one presented for lists. Perhaps the most surprising similarity is the retention of the reset()/getNext() pair for iterating over a tree. Trees don't have a natural next element.
There are two keys to how these dissimilar iterations are made to appear similar, one at the user level and one at the implementation level.
At the user level, we add a parameter orderType
to reset() (the book also adds it
to getNext(), I discuss the pros and cons later).
This parameter specifies the desired traversal order and hence gives
a meaning to
the next element.
Also reset() returns the size of the tree, enabling the user to call getNext() the correct number of times, which is important since getNext() has the additional precondition that it not be called after all items have been returned.
At the implementation level, we have reset() precompute all the next elements. Specifically, we define a queue, let reset() perform a full traversal enqueuing each item visited, and let getNext() simply dequeue one item.
public int reset(int orderType) { BSTQueue = new LinkedUnbndQueue<T>; if (orderType == INORDER) inOrder(root); else if (orderType == PREORDER) preOrder(root); else if (orderType == POSTORDER) postOrder(root); return size(); } public T getNext() { return BSTQueue.dequeue(); }
reset() creates a new queue (thus ending any previous iteration) and populates it with all the nodes of the tree.
The order of enqueuing depends on the parameter and is accomplished by a helper method.
The size of the tree, and hence the number of enqueued items, is returned to the user.
getNext() simply returns the next item from the queue.
private void inOrder(BSTNode<T> tree) { if (tree != null) { inOrder(tree.getLeft()); BSTqueue.enqueue(tree.getInfo(); inOrder(tree.getRight()); } } private void preOrder(BSTNode<T> tree) { if (tree != null) { BSTqueue.enqueue(tree.getInfo(); preOrder(tree.getLeft()); preOrder(tree.getRight()); } } private void inOrder(BSTNode<T> tree) { if (tree != null) { postOrder(tree.getLeft()); postOrder(tree.getRight()); BSTqueue.enqueue(tree.getInfo(); } }
These three methods, as shown on the right, are direct translations of the pseudocode given earlier. In these particular traversals, visiting a node means enqueuing it on BSTqueue from where they will be dequeued by getNext().
As previously remarked, the three traversals differ only in the placement of the visit (the enqueue) relative to the recursive traversals of the left and right subtrees.
In all three cases the left subtree is traversed prior to the right subtree.
As usual I do things slight differently from the authors. In this subsection, however, I made a real, user-visible change. The book defines three queues, one for each possible traversal. The reset() method enqueues onto the appropriate queue, depending on its parameter. The user-visible change is that getNext() also receives an orderType parameter, which it uses to select the queue to use.
The book's style permits one to have up to three iterations active at once, one using inorder, one preorder, and one postorder. I do not believe this extra flexibility warrants the extra complexity.
A nice test program, that I advise reading. The output from a run is in the book, the program itself is in .../bookFiles/ch08/IDTBinarySearchTree.java
In this comparison, we are assuming the items are ordered. For an unordered collection, a binary search tree (BST) is not even defined.
An array-based list seems the easiest to implement, followed by a linked list, and finally by a BST. What do we get for the extra work?
One difference is in memory usage. The array is most efficient, if you get the size right or only enlarge it by a small amount each time. A linked list is always the right size, but must store a link to the next node with each data item. A BST stores two links.
The table on the right compares the three implementations we have studied in terms of asymptotic execution time.
The BST looks quite good in this comparison.
In particular, for a large list with high
churn (additions
and removals), it is the clear winner.
The only expensive BST operation is reset() but that is deceptive. If you do a reset, you are likely to perform N getNext() operations, which also costs O(N) in total for all three data structures.
The time for an array-based constructor seems to assume you make the array the needed size initially. Instead of this, we learned how to enlarge arrays when needed.
The book enlarges by a fixed amount, which costs only O(1), but must be applied O(N) to reach a (large) size N. I double the size each time, which costs O(current size), but is only applied O(logN) times. The two methods cost about the same: O(N), which is also the same as needed if we make the array the full size initially.
The good performance attained by a BST depends on it being bushy. If it gets way out of balance (in the extreme example, if it becomes a line) then all the O(logN) boxes become O(N) and the data structure is not competitive.
There are two techniques to keeping the tree balanced, which one
might call the static vs dynamic approaches or might call the manual
vs automatic approaches.
We will
take the easy way out and follow the book by
presenting only the static/manual approach in which the user
explicitly invokes a balance() method when they feel the
tree might be imbalanced.
We will not consider the automatic approach in which the add and
remove operations themselves ensure that the tree is always
balanced.
Anyone interested in the automatic should type
AVL tree into
Google.
We will consider only the following 2-step approach.
For step 1 we presumably want to traverse the BST, but which traversal.
For step 2 we presumably want to use the BST add() method, but what order should we choose the elements from the array?
If we employ inorder and place consecutive elements into
consecutive array slots, the array is sorted.
If we then use add() on consecutive elements
(the
natural order), we get a line.
This is the worst possible outcome!
Now extract the elements with preorder and again add them back using consecutive elements of the array. This procedure is the identity, i.e., we get back the same tree we started with. A waste of time.
This procedure is harder to characterize, but it does not produce balanced trees. Let's try some.
Middle First
balance() n = tree.reset(INORDER); for (int i=0; i<n; i++) array[i] = tree.getNext() tree = new BinarySearchTree() tree.insertTree(0, n-1)
The code on the right shows the choice of inorder traversal.
Recall that reset() returns the current size of the tree,
which tells us how many times to execute getNext().
The fifth line on the right produces a new (empty) tree.
We now need to specify insertTree(), i.e., explain the cryptic
Middle First.
Since we use Inorder, the array is sorted. Whatever element we choose to add first will become the new root. For the result to be balanced, this element should be the middle of the sorted list. With a sorted array, the middle element is easy to find.
insertTree(lo, hi) if (hi == lo) tree.add(array[lo]) if (hi == lo+1) tree.add(array[lo] tree.add(array[hi] mid = (lo+hi)/2 tree.insertTree(lo, mid-1) tree.insertTree(mid+1, hi)
Now that the root is good, what is next. If we pick an element smaller than the middle it will become (and remain) the left child of the root. We want this tree node to have as many left as right descendants so we want the middle of the numbers smaller than our original middle. Etcetera.
This analysis gives rise to the algorithm on the right. If we have one or two elements we insert both (in either order; these are the base cases). Otherwise, insert the middle element and then insert the remaining small ones followed by inserting the remaining large ones (or vice-versa).
Homework: 46.
Start Lecture #22
Remark: Lab 5, the last lab, is posted.
The basic idea is easy. Use the following algorithm to store the binary tree in an array.
On the right we see three examples. The upper left example has 5 nodes. The root node A is stored in slot 0 of the array; it's left and right children are stored in slots 2*0+1 and 2*0+2 respectively.
The lower left is similar, but with 7 nodes.
The right example only has 6 nodes but requires 12 array slots, because some of the planed-for children are not in the tree, but array slots have been allocated for them.
Let's check that the rules for storing left and right children are satisfied for all three examples.
Definition: A binary tree like the one on the lower left in which all levels are full is called full.
Definition: A binary tree like the one on the upper left in which the only missing nodes are the rightmost ones on the last level is called complete.
The following properties are clear.
The array tree has the advantage that the parent (of a non-root node) can be found quickly. Its disadvantages are that, if the tree is not complete, space is wasted and, if an addition requires the array to have more slots than originally allocated, we must enlarge the array (or raise an exception).
Homework: 48,49.
Read.
A BST is an effective structure for storing sorted items. It does require two links per item, but essentially all operations are fast O(logN), providing the tree remains balanced. We presented an algorithm for explicitly re-balancing a BST and reference AVL trees as an example of BSTs that are automatically balanced.
First things first. A priority queue is not a queue. That is, it does not have FIFO semantics. I consider it a bad name, but it is much too late to try to change the name as it is absolutely standard.
In a priority queue, each item has an associated priority and
the
dequeue operation (I would call it remove since it is not
removing the first-in item) removes the
enqueued item with the
highest priority.
The priority of an item is defined by the Java class of the items.
In particular, we will normally assume x has higher
priority than y if x.compareTo(y)>0.
In fact sometimes the reverse is true and
smaller items
(according to compareTo() have higher priority.
We see the uml diagram on the right. It is quite simple: tests for full and empty and mutators that insert and remove an element.
The inclusion of isFull() suggests that we are using a bounded structure to hold the elements and indeed some implementations will do so. However, we can use an unbounded structure and just have isFull() always return false.
We specify that enqueuing onto a full queue or dequeuing from an empty queue raises an (unchecked) exception
In 202, when you learn process scheduling, you will see that often
an operating system wishes to run the
highest priority
eligible process.
We can also think of the triage system used at hospital emergency rooms as another implementation of priority scheduling and priority queues.
A real, (i.e., FIFO) queue is also a priority queue. The priority is then the negative of the time at which the enqueue occurs. With this priority the earliest enqueued item has the highest priority and hence is dequeued first.
The general point is that when the next item not picked at random, often some sort of (often not explicitly stated) priority is assigned to the items and the one selected scores best using this metric.
We are not short of methods to implement a priority queue. Indeed, we have already implemented the following four such schemes. However, each has a defect when used for this application.
Enqueuing is trivial, just append, and fast O(1). Dequeuing, however, requires that we scan the entire list, which is slow O(N), where N is the number of items.
We now have the reverse situation: Dequeuing is O(1) since the highest priority item is the last item, but enqueuing is O(N) since we have to shift elements down to make room for the new one (finding the insertion site is O(logN) if we use binary search and thus is not rate limiting).
Dequeuing is O(1) providing we sort the list in decreasing order. But again enqueuing is O(N).
Probably the best of the bunch. For a balanced BST, both enqueuing and dequeuing are O(logN), which is quite good. For random insertions the tree will likely be balanced but in the worst case (e.g., if the insertions come in sorted order) the tree becomes a line and the operations take O(N).
We can balance the tree on occasions, but this operation is always O(N).
The biggest problem with AVL trees is that we don't know what they are. They are also the fifth of the "four such schemes". Had we studied them or some other auto-balanced BST we would have seen that all operations are O(logN).
The AVL algorithms are somewhat complicated and AVL trees are overkill. We don't need to find an arbitrary element, just the largest one. Could we perhaps find a simpler O(logN) set of algorithm solving our simpler problem?
Yes we can and we study one next.
Homework: 3,4.
In future courses you will likely learn about regions of memory call the stack and the heap.
The stack region is used to store variables that have stack-like lifetimes, i.e. the first ones created are the last ones destroyed (think of f calls g and g calls h).
So the stack region is related to the stacks we have studied. However, the heap region is not related to the heaps we will study now.
Definition: A heap is a complete binary tree in which no child has a greater value than its parent.
Note that this definition includes both a shape property and an order property.
On the right we see four trees where each node contains a Character as its info field.
Question: Why are the bottom two trees not
heaps?
The left tree violates the order property since the right child of C is greater than C.
The right tree is not complete and thus violates the shape property.
Homework: 6, 7 (your example should have at least 4 nodes).
The picture on the right shows the steps in inserting a new element B into the first heap of the previous diagram.
Since the result must be a complete tree, we know where the new element must go. In the first row, all goes well the result of placing B in the required position yields another heap.
In the second row, we want to insert H instead of B and the result is not a heap since the order property is not satisfied. We must shift some elements around. The specific shifting that we will do, results in the rightmost tree.
An sequence of insertions is shown below, where, for variety, we use a heap in which smaller elements have higher priority. In each case the reheaping, often called a sift-up, consists of a sequence of local operations in which the inserted item is repeatedly compared with its parent and swapped if the ordering is wrong.
Let's make sure we understand every one of the examples.
We know that the highest priority element is the root so that is the element we must delete, but we also know that to maintain the shape property the position to be vacated must be the rightmost on the bottom row.
We meet both requirements by temporarily deleting the root, which we return to the user, and then moving the rightmost bottom element into the root position. But the result is probably not a heap since we have a just placed a low priority item into the slot reserved for the highest priority item.
We repair this damage by performing sift-downs, in which the root element is repeatedly swapped with its higher priority (in this example that means smaller) child.
On the board, start with the last tree from the previous diagram and perform several deletions. Note that the result of each delete is again a heap and hence the elements are removed in sorted (i.e., priority) order.
A key point in the heap implementation is that we use the array representation of a binary tree discussed last chapter. Recall that the one bad point of that representation was that when the tree is sparse, there may be many wasted array slots. However, for a heap this never the case since heaps are complete binary trees.
As I have mentioned Java generics have weaknesses, perhaps the most important of which is the inability to create generic arrays. For this reason the book (perhaps wisely) uses the ArrayList class from the Java library instead of using arrays themselves.
However, we have not yet used ArrayList in the regular section of the course and it does make the code look a little unnatural to have elements.add(i,x); rather than the familiar elements[i]=x;
For this reason I rewrote the code to use the normal array syntax
and that is what you will see below.
But, this natural code does not run and must
be
doctored in order to execute successfully.
In particular, various casts are needed and I offer a link to a
working (albeit ugly)
version here.
You should view the version in the notes as a model of what is
needed and the referenced working version as one way to bend it to
meet Java's weakness with generic arrays.
package priorityQueues; class PriQOverflowException extends RuntimeException { public PriQOverflowException() { super(); } public PriQOverflowException(String message) { super(message); } } package priorityQueues; class PriQUnderflowException extends RuntimeException { public PriQUnderflowException() { super(); } public PriQUnderflowException(String message) { super(message); } }
Since we are basing our implementation on fixed size arrays, overflows occur when enqueuing onto a full heap. Underflows always occur when dequeuing any empty structure.
We follow the book and have underflows and overflows each trigger a java RuntimeException. Recall that these are unchecked exceptions so a user of the package does not need to catch them or declare that it might throw them.
Each of our exceptions simply calls the constructor in the parent class (namely RuntimeException.
package priorityQueues; public class Heap<T extends Comparable<T>> implements PriQueueInterface<T> { private T[] elements; private int lastIndex = -1; private int maxIndex; public Heap(int maxSize) { elements = new T[maxSize]; maxIndex = maxSize - 1; }
As with BSTs, heaps have an inherent order among their elements. Hence we must again require that T extends Comparable<T>.
Recall that the heap will be implemented as an array. maxIndex is essentially the physical size of the array; whereas, lastIndex, designating the highest numbered full slot is essentially the size of the heap since all lower slots are also full.
The constructor is given the size of the array from which it
creates the array and the largest possible index.
We know that the new statement is illegal.
In previous array-based structures
(e.g., ArrayUnsortedList), a simple
cast
fixed the problem, but here more work was needed (see my
doctored code.
public boolean isEmpty() { return lastIndex == -1; } public boolean isFull() { return lastIndex == maxIndex; }
These are trivial.
public void enqueue (T element) throws PriQOverflowException { if (lastIndex == maxIndex) throw new PriQOverflowException("helpful message"); lastIndex++; reheapUp(element); } private void reheapUp(T element) { int hole = lastIndex; while ((hole>0) && (element.compareTo(elements[parent(hole)])>0)) { elements[hole] = elements[parent(hole)]; hole = parent(hole); } elements[hole] = element; } private int parent(int index) { return (index-1)/2; }
If the heap is filled, enqueue() raises an exception; otherwise it increases the size of the of the heap by 1.
Rather than placing the new item in the new last slot and then
swapping it up to its final position, we place a
hole in the
slot and swap the hole up instead.
We place the new item in the hole's final location.
This procedure is more efficient since it takes only two assignments to swap a hole and an element, but takes three to swap two elements.
To make the code easier to read I recompute the parent's index twice and isolate the computation in a new method. It would be more efficient to compute it once inline; an improvement that an aggressive optimizing compiler would perform automatically.
public T dequeue() throws PriQUnderflowException{ if (lastIndex == -1) throw new PriQUnderflowException("Helpful msg"); T ans = elements[0]; T toMove = elements[lastIndex--]; if (lastIndex != -1) reheapDown(toMove); return ans; } private void reheapDown(T element) { int hole = 0; int newhole = newHole(hole, element); while (newhole != hole) { elements[hole] = elements[newhole]; hole = newhole; newhole = newHole(hole, element); } elements[hole] = element; } private int newHole(int hole, T element) { int left = 2 * hole + 1; int right = 2 * hole + 2; if (left > lastIndex) // no children return hole; if (left == lastIndex) // one child return element.compareTo(elements[left])<0? left: hole; if (elements[left].compareTo(elements[right]) < 0) return element.compareTo(elements[right])<0? right: hole; return element.compareTo(elements[left])<0? left: hole; }
If the queue is empty, dequeue() raises and exception; otherwise it returns the current root to the user and hence decreases the heap's size by 1. Removing the root leaves a hole there, which is then filled with the current last item, restoring the shape property.
But
elevating the last item is likely to violate the order
property.
This violation can be repaired by successively swapping the item with
its larger child.
Instead of successively swapping two items, it is again more efficient to successively swap the hole (currently the root position) with its larger child and only at the end move the last item into the final hole location.
The process of swapping the hole down the tree is called sift-down or reheap-down.
Finding the larger child and determining if it is larger than the parent is easy but does take several lines so is isolated in the newhole() routine.
// for testing only public String toString() { String theHeap = new String("The heap is\n"); for (int i=0; i<=lastIndex; i++) theHeap += i + ". " + elements[i] + "\n"; return theHeap; } }
A useful aid in testing the heap and many other classes, is to override the toString() method defined for any Object.
Since a heap is implemented as an array, the code on the right, which just lists all the array slots with their corresponding indices, is quite useful for simple debugging.
A heap would user would likely prefer a graphical output of the corresponding tree structure, but this is more challenging to produce.
Start Lecture #23
Remark: As guessed the (hole>1) was a typo and has been fixed. Note that the book's test case worked fine on both the wrong and corrected version. The limitation of (not extensive) testing.
The table on the right compares the performance of the various structures used to implement a priority queue. The two winners are heaps and balanced binary search trees.
Our binary search trees can go out of balance and we need to judiciously choose when to re-balance (an expensive O(N) operation).
As mentioned there are binary search trees (e.g. AVL trees) that maintain their balance and still have the favorable O(logN) performance for all operations. However, these trees are rather complicated and are overkill for priority queues where we need only find the highest element.
Homework: 10, 11.
We discussed priority queues, which can be implemented by several data structures. The two with competitive performance are the binary search tree and the heap. The former is overkill and our BST implementations did not fully address the issue of maintaining balance.
In this chapter we described a heap in detail including its implementation. Since heaps are complete binary trees an array-based implementation is quite efficient.
We skipped the material on graphs.
Given an unsorted list of elements, searching is inherently slow (O(N)) whether we seek a specific element, the largest element, the smallest element, or the element of highest/lowest priority.
In contrast a sorted list can be searched quickly:
But what if you are given an unsorted list and want it sorted? That is the subject of this chapter together with other searching techniques that in many cases can find an arbitrary element in constant time.
Sorting is quite important and considerable effort has been given to obtaining efficient implementations.
It has been proven that no
comparison-based
sorting algorithm can do better than O(NlogN).
We will see algorithms that achieve this lower bound as well as
simpler algorithms that are slower (O(N2)).
Roughly speaking a sorting algorithm is comparison-based if it sorts by comparing elements of the array. Any natural algorithm you are likely to think of is comparison-based. In basic algorithms you will see a more formal definition.
We will normally write
in-place sorting algorithms that do
not use significant space outside the array to be sorted.
The exception is merge sort.
public class TestSortingMethod { private static final int SIZE = 50; private static final int DIGITS = 3; // change printf %4d private static final int MAX_VALUE = (int)Math.pow(10,DIGITS)-1; private static final int NUM_PER_LINE = 10; private static int[] values = new int[SIZE]; private static int numSwaps = 0; private static void initValues() { for (int i=0; i<SIZE; i++) values[i] = (int)((MAX_VALUE+1)*Math.random()); } private static boolean isSorted() { for (int i=0; i<SIZE-1; i++) if (values[i] > values[i+1]) return false; return true; } private static void swap (int i, int j) { int t = values[i]; values[i] = values[j]; values[j] = t; numSwaps++; } private static void printValues() { System.out.println("The value array is:"); for (int i=0; i<SIZE; i++) if ((i+1) % NUM_PER_LINE == 0) System.out.printf("%4d\n", values[i]); else System.out.printf("%4d" , values[i]); System.out.println(); } public static void main(String[] args) { initValues(); printValues(); System.out.printf("The array %s initially sorted.", isSorted() ? "is" : "is not"); sortValues(); printValues(); System.out.printf("After performing %d swaps,\n", numSwaps); System.out.printf("the array is %s sorted.", isSorted() ? "now" : "still not"); } private static void sortValues() { // call sort program here } }
Since we will have several sort routines to test we write a general
testing
harness into which we can plug any sorting routing
that sorts an int[] array named values.
The harness initializes values to random non-negative integers, prints the values, checks if the initial values are sorted (probably not), calls the sort routine in question, prints the array again, and checks if the values are now sorted.
In order to be flexible in testing, the harness uses three configuration constant, SIZE, the number of items to be sorted DIGITS the number of digits in each number, and NUM_PER_LINE, the number of values printed on each line.
The maximum value (used in generating a problem) is calculated from DIGITS, but the %4d in printf() must be changed manually.
The following output is produced when the configuration constants are set as shown on the right. The array is not initialy sorted. After performing 0 swaps, the array is still not sorted.
For convenience, a swap() method is provided that keeps track of how many swaps have been performed.
These algorithms are simple (a virtue), but slow (a defect). They are the obvious choice when sorting small arrays, say a hundred or so entries, but are never used for serious sorting problems with millions of entries.
I am not sure what the adjective
straight means here.
The idea behind selection sort is simple.
private static void selectionSort() { for (int i=0; i<SIZE-1; i++) swap(i, minIndex(i, SIZE-1)); } private static int minIndex(int startIndex, int endIndex) { int ans = startIndex; for (int i=startIndex+1; i<=endIndex; i++) if (values[i] < values[ans]) ans = i; return ans; }
The code, shown on the right is also simple.
The outer loop (selectionSort() itself) does
the
etcetera.
That is, it causes us to successively swap the first with the
minimum, the second with the minimum from 2 down, etc.
The minIndex routine finds the index in the given range whose slot contains the smallest element. For selectionSort(),endIndex could be omitted since it is always SIZE-1, but in other sorts it is not.
Selection sort is clearly simple and we can see from the code that it uses very little memory beyond the input array. However, it is slow.
The outer loop has N-1 iterations (N is SIZE, the size of the problem). The inner loop first has N-1 iteration, then N-2, ..., finally 0 iterations.
Thus the total number of comparisons between two values is
N-1 + N-2 + N-3 + ... + 1
You will learn in basic algorithms that this sum equals (N-1)(N-1+1)/2=O(N2), which is horrible when say N=1,000,000.
private static void bubbleSort() { boolean sorted = false; while (!sorted) { sorted = true; for (int i=0; i<SIZE-1; i++) if (values[i] > values[i+1]) { swap(i, i+1); sorted=false; } } }
Bubble and selection sorts both try to get one element correct and then proceed to get the next element correct. (For bubble it is the last (largest) element that is corrected first.) A more significant difference is that bubble sort only compares and swaps adjacent elements and performs more swaps (but not more comparisons).
There are several small variations on bubble sort.
The version on the right is one of the simplest.
Although there are faster versions they are
all O(N2) in the worst case so are never used
for large problems unless the problems are known to be
almost
sorted.
This analysis is harder than for selection sort; we shall skip it.
private static void insertionSort() { for (int i=1; i<SIZE; i++) { int j = i; while (j>0 && values[j-1]>values[j]) { swap(j, j-1); j--; } } }
For this sort we take each element and insert it where it belongs in the elements sorted so far. Initially, the first element is itself sorted. Then we place the second element where it belongs with respect to the first, and then the third with respect to the first two, etc.
In more detail, when elements 0..i-1 have been sorted, swap element i with elements i-1, i-2, ..., until the element is in the correct location.
The best case occurs when the array is already sorted, in which case the element comparison fails immediately and no swaps are done.
The worst case occurs when the array is originally in reverse order, in which case the compares and swaps always go all the way to the first element of the array. This again gives a (worst case) complexity of O(N2)
Homework: 2,5,6,8.
These are the ones that are used for serious sorting.
private static void mergeSort(int first, int last) { if (first < last) { int middle = (first+last) / 2; mergeSort(first, middle); mergeSort(middle+1, last); merge(first, middle, last); } } private static void merge(int leftFirst, int leftLast, int rightLast) { int leftIndex = leftFirst; int rightIndex = leftLast+1; int[] tempArray = new int[rightLast-leftFirst+1]; int tempIndex = 0; while (leftIndex<=leftLast && rightIndex<=rightLast) if (values[leftIndex] < values[rightIndex]) tempArray[tempIndex++] = values[leftIndex++]; else tempArray[tempIndex++] = values[rightIndex++]; while (leftIndex <= leftLast) tempArray[tempIndex++] = values[leftIndex++]; while (rightIndex <= rightLast) tempArray[tempIndex++] = values[rightIndex++]; for (tempIndex=0; tempIndex<tempArray.length; tempIndex++) values[leftFirst+tempIndex] = tempArray[tempIndex]; }
The mergesort routine itself might look too simple to work, much less to be one of the best sorts around. The reason for this appearance is its recursive nature. To mergesort the array, use mergesort to sort the first half, then use mergesort to sort the second half, then merge these two sorted halves.
Merging two sorted lists is easy. I like to think of two sorted decks of cards.
Compare the top card of each pile and take the smaller. When one of the piles is depleted, simply take the remainder of the other pile.
Note that the tempArray for the last merge performed is equal in size to the initial array. So merge sort requires O(N) additional space, a disadvantage.
The analysis is harder than the program and I leave the details for basic algorithms. What follows is the basic idea.
To simplify slightly let's assume we are sorting a power of two
numbers.
On the right is the
merge tree for sorting 16=24
values.
From the diagram we see 31 calls to mergeSort(), one of size 16, two of size 8, ..., 16 of size 1. For any power of two there will be 2N-1calls if we are sorting N, a power of 2, values.
MergeSort() itself is trivial, just 3 method calls, i.e. O(1), and hence all the calls to mergeSort() combined take O(N).
What about the calls to merge()? Each /\ in the diagram corresponds to a merge. If you look at the code for Merge(), you can see that each call is O(k), when you are merging k values. The bottom row of the diagram contains 8 merges, each merging two values. The next row contains 4 merges, each of 4 values. Indeed, in each row N=16 elements are merged it total. So each row of merges requires O(N) effort.
Question: How many rows are there?
Answer: logN.
Hence the total effort for all the merges is O(NlogN). Since all the mergeSort() routines take only O(N), the total effort for mergesort is O(NlogN) as desired.
Homework: 11,12.
This algorithm is
obvious but getting it right is hard as
there are many details and potential
off by one pitfalls.
Like mergeSort(), quickSort() recursively divides the array into two pieces which are sorted separately. However, in this algorithm one piece has all the small values, the other all the large ones. Thus there is no merging needed.
The recursion ends with a base case in which the piece has zero of one items and thus is already sorted.
The idea is that we choose one of the values in the array (call it X) and swap elements so that everything in the left (beginning) part of the array is less than or equal to X, everything in the right part is greater than X, and X is in between the two parts.
Now X is correctly located and all we need to do is sort each of the two parts. The clever coding is needed to do the swapping correctly.
We will do examples on the board, but not study the coding. All the sorting algorithms are available here.
The speed depends on how well the array is divided. If each piece is about 1/2 size, the time is great O(NlogN). If one piece is extremely small, the time is poor O(N2).
The key to determining the sizes of the pieces is the choice X above. In my code, X is set to the first value in the interval to be reordered. Like any other choice of X, this can sometimes be bad and sometimes be good.
It should be noted that, if the original array is almost sorted, this choice of X is bad. Since such arrays often arise in practice, real quicksort programs use a different X. The book suggests the middle index in the range; others suggest taking the first, last, and middle index and choosing the one whose value is in the middle of the three.
Any of these choices have as many bad cases as any other, the point of using something other than simply the first entry is that for the others the bad cases are not as common in practice as an almost sorted array.
private static void heapSort() { PriQueueInterface<Integer> h = new Heap(values.length); for (int i=0; i<values.length; i++) h.enqueue(values[i]); for (int i=values.length-1; i>=0; i--) values[i] = h.dequeue(); }
On the right is a simple heapsort using our heap from chapter 9. I am surprised the book didn't mention it.
A disadvantage of the simple heapsort is that it uses an extra array (the heap h). The better algorithm in the book builds the heap in place so uses very little extra space.
Although the values array is not a heap, it does satisfy the shape property. Also, all the leaves (the array entries with the largest indices) are valid subheaps so we start with highest-indexed, non-leaf and sift it down using a variant ofreheapDown() from chapter 9. Then we proceed up the tree and repeat the procedure.
I added an extra print to heapsort in the online code to show the array after it has been made into a heap, but before it has become sorted.
Now that we have a heap, the largest element is in values[0]. If we swap it with values[SIZE-1], we have the last element correct and hence no longer access it.. The first SIZE-1 elements are almost a heap, just values[0] is wrong. Thus a single reheapDown() restores the heap and we can continue.
Homework: 19, 22, 23
All the sorting algorithms are implemented here embedded in the test harness developed earlier. To run the a given sorting program, go to the sortValues() method and comment out calling all the other sorts.
Several good general comments about testing as applied to sorting.
public static void badSort(int[] a) { for (i=0; i<a.length; i++) a[i] = i; }
However, there is an important consideration that is not normally
discussed and that is rather hard to check.
Executing the method on the right results
in a being
sorted; however, the
result bears little resemblance to the original array.
Many sort checkers would
validate badSort().
We have paid little attention to small values of N. The real concern is not for small problems; they are fast enough with any method. The issue arises with recursive sorts. Using heapsort, mergesort, or quicksort on a large (say 1,000,000) entry array results in very many recursive calls to small subproblems that can be solved more quickly with a simpler sort.
Good implementations of these recursive algorithms call a simpler sort when the size of the subproblem is below a threshold.
Method calls are not free. The overhead of the call is especially noticeable when a method with a small body called often. Programmers and good compilers can eliminate many of these calls.l
Most of the time minor performance improvements such as eliminating method calls are not made ... with good reason. The primary quality metric for all programs is correctness. For most programs, performance is not the second quality metric; instead ease of modification, on time completion, and cost rank higher. Cost is basically programmer time so it is not wise to invest considerable effort for small performance gains.
Note that the preceding paragraph does not apply to the huge gains that occur in large problems when a O(NlogN) algorithm replaces an O(N2) algorithm.
The only significant difference in storage space required is between those algorithms (mergesort and quicksort) that require extra space proportional to the size of the array and those that do not. Normally, we worry more about time than space, but the latter does count.
You might worry that if we are sorting large objects rather than primitive int's or tiny Character's, that swapping elements. For example, if we had an array of String's and it turned out that each string was a book containing about a million characters, then swapping two of these String's would be very expensive indeed.
But that is wrong!
The swaps do not actually swap the million character strings but swap the (small) references to the strings.
We have used this interface many times. The only new point in this section is to note that a class can have only one CompareTo() method and thus can only be sorted on one basis.
There are cases where you want two different orderings. For example, you could sort airline flights on 1 March from NYC to LA by time of day or by cost for the cheapest coach ticket. Comparable does not offer this possibility.
The somewhat more complicated Comparitor interface is based on a compare() method with two parameters, the values to be compared. The interesting part is the ability to have multiple such methods. However, we will not pursue this interface further.
A sort is called stable if it preserves the relative order of duplicate values. This becomes important when an object has several fields and you are only sorting based on one field. Thus duplicated objects need only have the sorted field equal and hence duplicates are not necessarily identical.
Assume you first sort on one field and then on a second. With a stable sort you are assured that items with equal second field have their first fields in order.
Sometimes searching is not needed. If we have an indexed list implemented with an array A of objects of some class C, then obtaining entry number 12 is simply retrieving A[12], a constant time (i.e., O(1) operation.
To be specific, assume C consists of NYU students and an object in C contains the students name, N number, and major. Then finding the major of the student in entry 12 is simply A[12].NNumber, again an O(1) operation.
However, many times the easy solution above is not possible.
For example, with the same implementation finding the entry number
of a student named
Tom Li require searching, as does
finding Li's major.
Linear searching (trying the first object, then the second, etc.) is always possible, but is slow (O(N) for N objects).
In many circumstances, you know that there will be
popular
and
unpopular object.
That is, you know there will be some objects searched for much
more frequently than others.
If you know the identity of the popular objects you can place them
first so that linear search will find them quickly.
But what if you know only that there are popular objects but don't
know what they are?
In this last situation the
move to the front algorithm
performs well (I often use it for physical objects).
When you search for and find an object, move it to the front of
the list (sliding objects that preceded it down one slot).
After a while this will have popular objects toward the front and
unpopular objects toward the rear.
For physical objects (say documents) it is often O(1) to move a found object to the front. However, for an array the sliding down can be O(N). For this reason, an approximation is sometimes used where you simply swap the found object with the first, clearly an O(1) task.
Knowing that a list is sorted helps linear search and often permits the vastly faster binary search.
When linearly searching a sorted list for an element that is not present, one can stop as soon as the search passes the point where the item would have been stored, reducing the number of items search to about half on average.
More significantly, for an array-based sorted list we can use the O(logN) binary search, a big speed advantage.
Start Lecture #24
We learned that if a list is unsorted we can find an element in the list (or determine that the element is not there) in time O(N) using linear searching (try the first, then the second, etc.).
If the list is sorted we can reduce the searching time to O(logN) by using binary search (roughly: try the middle, then the middle of the correct half, then the middle of the correct quarter, etc.).
Can we ever hope to find an element in a list using a constant amount of time (i.e., the time to lookup an element does not depend on the number of elements?
In fact this is sometimes possible. I found on the web the roster of this year's NY Jets football team. Assume you have an array of strings NYJets with NYJets[11]="Kerley", NYJets[21]="Bell", NYJets[18]="*", etc. Then you can answer questions like these in constant time.
We say that the player number is the key.
But this case is too easy. Not only are there very few entries, but the range of indices is small.
Now consider a similar list of the students in this class with key
their their NYU
N numbers.
Again there are very few entries (about 50), but now the range of
indices is huge.
My N number has 8 digits so we would need an array of 100,000,000
entries with all but 50 being "*".
This situation is when hashing is useful.
The book makes the following three assumptions to simplify the discussion.
Some comments on these assumptions.
Instead of indexing the array by our N numbers, instead take just the last 3 digits (i.e., compute (N number) % 1000). Now we only need an array of size 1,000 instead of 100,000,000.
Definition: The function mapping the original key to another (presumably smaller) value, which is then used to access the table, is called a hash function.
For now we will use the above hash function, i.e., we take the key modulo the size of the table.
All is well, searching is O(1), PROVIDING no two N numbers in the class end in the same three digits, i.e., providing we have no collisions.
public class Student { private int nNumber; // the key private String name; private String major; // etc public Student(int nNumber, String name, String major) { this.nNumber = nNumber; this.name = name; this.major = major; } public int getNNumber() { return nNumber; } public String getName() { return name; } public String getMajor() { return major; } public void setNNumber(int nNumber) { this.nNumber = nNumber; } public void setname(String name) { this.name = name; } public void setMajor(String major) { this.major = major; } } public class StudentHashtable { private Student[] studentHashtable; private int size; public StudentHashtable(int size) { this.size = size; studentHashtable = new Student[size]; } public int hash(int key) { return key % size; } public void add (Student s) { studentHashtable[hash(s.getNNumber())] = s; public Student get(Student s) { return studentHashtable[hash(s.getNNumber())]; } }
Although we will not be developing hashtables to the point of actual code, I thought it would be helpful to see a possible basic setup.
It would be better to have a generic hashtable class that accepted as type parameter (the <T> business) the type of object being stored, I didn't want to battle with generic arrays since we aren't actually going to use the implementation.
So I was inelegant and made the class specific to the object being stored, in this case Student.
I defined a standard hash() method taking and returning an int. Were we developing a complete implementation, I might have defined it as taking a Student as input and then have hash() itself extract the nNumber, which it would then use as key.
Our add() is easy.
The get() method returns the entry from the hashtable that is equal to the argument.
Something must be wrong. This is too easy.
A minor simplification is that we assume there is room for the element we add and are assuming the element we are asked to get is present. We could fix the former by keep track of the size; and fix the latter by checking the found entry and returning null if it doesn't match.
The real simplification is that we assume collisions don't happen. That is we assume that different keys are hashed to different values. But this is clearly not guaranteed. Imagine we made a 1000 entry table for NYU students and picked say 900 students. Our hash function just returns the last three digits of their N number. I very much doubt that 900 random NYU students all have unique 3-digit N number suffixes. Collisions do and will happen. The question is what to do when they occur, which is our next topic.
One can attack collisions in two ways: minimize their occurrence and reduce the difficulty they cause. We will not do the former and will continue to just use the simple mod function.
One place where collisions occur is in the add() method. Naturally, if you add an element twice, both will hash to the same place. Let's ignore that possibility and say we never add an element already present. When we try to add an element, we store the element in the array slot given by the hash of the key. A collision occurs when the slot already contains a (different) entry.
We need to find a location to store an item that hashes to the same value as an already stored item. There are two classes of solutions: open addressing and separate chaining.
public void add (Student s) { int location = hash(s.getNNumber()); while (studentHashtable[location] != null) location = (location+1) % capacity; studentHashtable[location] = s; } public Student get(Student s) { int location = hash(s.getNNumber()); while (studentHashtable[location].getNNumber()!=s.getNNumber()) location = (location+1) % capacity; return studentHashtable[location]; }
The simplest example of open addressing is linear probing. When we hash to a full slot, we simply try the next slot, i.e., we increase the slot number by 1 (mod capacity).
The new versions of add() and get() are on the right. The top loop would not terminate if the table is full; the bottom loop would not terminate if the item was not present. However, we are assuming that neither of these conditions holds.
As mentioned above it is not hard to eliminate these assumptions.
Homework: 42
More serious is trying to support delete and search.
Let the capacity be 10 and do the following operations.
Insert 13; Insert 24; Insert 23; Delete 24;
The result is shown on the right.
If you now look for 23, you will first try slot 3 (filled with 13) and then try slot 4 (empty since 24 was deleted). Since 23 would have gone here, you conclude erroneously that it is not present.
The solution is not to mark a deleted slot as empty (null) but instead as deleted (I will use **). Then the result looks as shown on the right and an attempt to find 23 will proceed as follows. Try slot 3 (filled with 13), try 4 (a deleted item), try slot 5 (success).
A problem with open addressing, particularly with linear probing
is that clusters develop.
After one collision we now have a block of two elements that hash to
one address.
Hence the next addition will be in this
cluster if it hashes
to either of the two address.
With a cluster of three, now any new item that hashes to one of the
three will add to the cluster.
In general clustering becomes very severe if the array is nearly full. A common rule of thumb is to ensure that the array is less than 70% full.
Instead of simply adding one to the slot number, other techniques are possible. Choosing the new addresses when a collision occurs is called rehashing. This is a serious subject, the book only touches on it; we shall skip it.
(Note I split up the books
Bucket and Chaining section.)
Sometimes instead of an array of slots each capable of holding one
item, the hash table is an array of buckets each capable of holding
a small fixed number of items.
If a bucket has space for say 3 items then there is no problem if
up to 3 items hash to the same bucket.
But if a 4th one does we must do something else.
One possibility is to go to the next bucket which is similar to open addressing / linear probing.
Another possibility is to store all items that overflow any bucket
in one large
overflow bucket.
Homework: 44.
In open addressing the hash value gives the (first) slot number to try for the given item and collisions result in placing items in other slots. In separate chaining the hash value determines a bucket into which the item will definitely be placed.
The adjective separate is used to indicate that items with different hash values will be kept separate
Since items will definitely be placed in the bucket they are hashed to, these buckets will contain multiple items if collisions occur. Often the bucket is implemented as a list of chained (i.e., linked) nodes, each node containing one item.
A linked list sounds bad, but remember that the belief/hope is that there will not be many items hashing to the same bucket.
Other structures (often tree-based) can be used if it is feared that many items might hash to the same bucket.
Homework: 45, 46 (ignore the reference to #43), 47, 48.
Naturally a good hash function must be fast to computer. Our simple modulo function was great in that regard. The more difficult requirement is that it not give rise to many collisions.
To choose a good hash function one needs knowledge of the statistical distribution of the keys.
This is what we used.
If there were no collisions, hashing would be constant time, i.e., O(1), but there are collisions and the analysis is serious.
Sorting, searching, and hashing are important topics in practical applications. There is much we didn't cover. For example, we didn't concern ourself with the I/O considerations that arise when the items to be sorted or searched are stored on disk. We also ignored caching behavior.
Often the complexity analysis is difficult. We barely scratched the surface; Basic Algorithms goes further.
Start Lecture #25
Remark: See the CS web page for the final exam location and time.
Went back and briefly covered 10.4 and 10.5. However, these sections remain optional and will not be on the final exam.
Start Lecture #26
Reviewed practice exam.
Here are the UMLs for the major structures studied. | http://cs.nyu.edu/courses/fall12/CSCI-UA.0102-001/class-notes.html | CC-MAIN-2013-48 | refinedweb | 43,694 | 64.51 |
Technical Support
On-Line Manuals
RL-ARM User's Guide (MDK v4)
#include <rtl.h>
BOOL tftpc_put (
U8* ipadr, /* IP address of the TFTP server. */
U16 port, /* Port number of TFTP server. */
const char *src, /* Name of the local file to send. */
const char *dst, /* Name of the file on TFTP server. */
void (*cbfunc)(U8 event) ); /* Function to call when the session ends. */
The tftpc_put function starts the TFTP client on the TCPnet
system to transfer a file from the local system to remote TFTP
server. This causes the TFTP client to then start a TFTP session by
connecting to a TFTP server on the UDP port specified in the
function argument. If the port is not specified, that is the
argument port has a value of 0, the system uses a standard
TFTP server port to connect to.
The argument ipadr points to an array of 4 bytes containing
the dotted-decimal notation of the IP address of the TFTP server to
connect to.
The arguments src and dst are pointers to
0-terminated names of source and destination files. Source file is a
local file that is going to be sent. Destination file is a file on
TFTP server, where the file content will be copied to. If the
destination file is not specified, that is the argument dst
has a value of NULL, then the name of the source file becomes also a
name of the destination file.
The argument cbfunc points to a function that the TFTP
client running on TCPnet calls when the TFTP session ends. The
cbfunc is an event callback function that uses the
event argument of the cbfunc function to signal one of
the following TFTP events:
The tftpc_put function is in the RL-TCPnet library. The
prototype is defined in rtl.h.
note
The tftpc_put function returns __TRUE if the TFTP client
has been successfully started. Otherwise it returns __FALSE.
tftpc_get
static void tftpc_notify (U8 event);
void send_file (void) {
U8 tftp_srv[4] = {192,168,2,253};
if (tftpc_put (tftp_srv, 0, "LPC23_EMAC.c", NULL, tftpc_notify) == __FALSE) {
printf("File transfer not started, TFTP Client not ready.\n");
}
else {
printf("File transfer started.\n");
}
}
static void tftpc_notify (U8 event) {
switch (event) {
case TFTPC_EVT_SUCCESS:
printf ("File successfully transferred.\n");
break;
case TFTPC_EVT_TIMEOUT:
/* Timeout, try again. */
printf ("TFTP Server timeout.\n");
break;
default:
/* Error, try again. */
printf ("Error transferring file.. | http://www.keil.com/support/man/docs/rlarm/rlarm_tftpc_put.htm | CC-MAIN-2020-05 | refinedweb | 394 | 65.83 |
The name Scala stands for “scalable language.” The language is so named because it was designed to grow with the demands of its users. You can apply Scala to a wide range of programming tasks, from writing small scripts to building large systems.
Scala is easy to get into. It runs on the standard Java platform and it interoperates seamlessly with all Java libraries. It’s a great language for writing scripts that pull together Java components. But it can play out its strengths even more anxious to start writing some Scala code, you should jump ahead to Chapter 2, “First Steps in Scala.”
Programs of different sizes tend to require different programming constructs. Consider, for example, the following small Scala program:
var capital = Map("US" -> "Washington", "France" -> "Paris") capital += ("Japan" -> "Tokyo") println(capital("France"))This program sets up a map from countries to their capitals, modifies the map by adding a new binding
("Japan" -> "Tokyo"), and prints the capital associated with the country France. The notation in this example is high-level, to the point, and not cluttered with extraneous semicolons or type annotations. Indeed, the feel is that of a modern “scripting” language like Perl, Python or Ruby. One common characteristic of these languages, which is relevant for the example above, is that they each support an “associative map” construct in the syntax of the language.
Associative maps are very useful because they help keep programs legible and concise. However, sometimes you might not agree with their “one size fits all” philosophy, because you need to control the properties of the maps you use in your program in a more fine-grained way. Scala gives you this fine-grained control if you need it, because maps in Scala are not language syntax. They are library abstractions that you can extend and adapt.
In the above program, you’ll get a default
Map implementation,
but you can easily change that.
You could for example specify a particular implementation, such as a
HashMap or a
TreeMap, or you could specify that the map should
be thread-safe, “mixing in” a
SynchronizedMap “trait.” You
could specify a default value for the map, or you could override any
other method of the map you create. In each case, you can use the same easy access syntax for
maps as in the example above.
This example shows that Scala can give you both convenience and flexibility. Scala has a set of convenient constructs that help you get started quickly and let you program in a pleasantly concise style. At the same time, you have the assurance that you will not outgrow the language. You can always tailor the program to your requirements, because everything is based on library modules that you can select and adapt as needed.
Eric Raymond introduced the cathedral and bazaar as two metaphors of software development.1 The cathedral is a near-perfect building that takes a long time to build. Once built, it stays unchanged for a long time. The bazaar, by contrast, is adapted and extended each day by the people working in it. In Raymond’s work the bazaar is a metaphor for open-source software development. Guy Steele noted in a talk on “growing a language” that the same distinction can be applied to language design.2 Scala is much more like a bazaar than a cathedral, in the sense that it is designed to be extended and adapted by the people programming in it. Instead of providing all constructs you might ever need in one “perfectly complete” language, Scala puts the tools for building such constructs into your hands.
Here’s an example. Many applications need a type of integer
that can become arbitrarily large without overflow or “wrap-around”
of arithmetic operations. Scala defines such a type in a library class
scala.BigInt. Here is the definition of a method using that type, which calculates
the factorial of a passed integer value:3
def factorial(x: BigInt): BigInt = if (x == 0) 1 else x * factorial(x - 1)Now, if you call
factorial(30)you would get:
265252859812191058636308480000000
BigIntlooks like a built-in type, because you can use integer literals and operators such as
*and
-with values of that type. Yet it is just a class that happens to be defined in Scala’s standard library.4 If the class were missing, it would be straightforward for any Scala programmer to write an implementation, for instance, by wrapping Java’s class
java.math.BigInteger(in fact that’s how Scala’s
BigIntclass is implemented).
Of course, you could also use Java’s class directly. But the result is not nearly as pleasant, because although Java allows you to create new types, those types don’t feel much like native language support:
import java.math.BigInteger def factorial(x: BigInteger): BigInteger = if (x == BigInteger.ZERO) BigInteger.ONE else x.multiply(factorial(x.subtract(BigInteger.ONE)))
BigIntis representative of many other number-like types—big decimals, complex numbers, rational numbers, confidence intervals, polynomials—the list goes on. Some programming languages implement some of these types natively. For instance, Lisp, Haskell, and Python implement big integers; Fortran and Python implement complex numbers. But any language that attempted to implement all of these abstractions at the same time would simply become too big to be manageable. What’s more, even if such a language were to exist, some applications would surely benefit from other number-like types that were not supplied. So the approach of attempting to provide everything in one language doesn’t scale very well. Instead, Scala allows users to grow and adapt the language in the directions they need by defining easy-to-use libraries that feel like native language support.
The previous example demonstrates that Scala lets you add new types that can be used as conveniently as built-in types. The same extension principle also applies to control structures. This kind of extensibility is illustrated by Scala’s API for “actor-based” concurrent programming.
As multicore processors proliferate in the coming years, achieving acceptable performance will demand you use more parallelism in your applications. Often, this means rewriting your code so that computations are distributed over several concurrent threads. Unfortunately, creating dependable multi-threaded applications has proven challenging in practice. Java’s threading model is built around shared memory and locking, a model that is often difficult to reason about, especially as systems scale up in size and complexity. It is hard to be sure you don’t have a race condition or deadlock lurking—something that didn’t show up during testing, but might just show up in production. An arguably safer alternative is a message passing architecture such as the “actors” approach used by the Erlang programming language.
Java comes with a rich thread-based concurrency library. Scala programs can use it like any other Java API. However, Scala also offers an additional library that essentially implements Erlang’s actor model.
Actors are concurrency abstractions that can be implemented on top of
threads. They communicate by sending messages to each other. An actor
can perform two basic operations, message send and receive. The send
operation, denoted by an exclamation point
(!), sends a message to
an actor. Here’s an example in which the actor is named
recipient:
recipient ! msgA send is asynchronous; that is, the sending actor can proceed immediately, without waiting for the message to be received and processed. Every actor has a mailbox in which incoming messages are queued. An actor handles messages that have arrived in its mailbox via a
receiveblock:
receive { case Msg1 => ... // handle Msg1 case Msg2 => ... // handle Msg2 // ... }A receive block consists of a number of cases that each query the mailbox with a message pattern. The first message in the mailbox that matches any of the cases is selected, and the corresponding action is performed on it. If the mailbox does not contain any messages that match one of the given cases, the actor suspends and waits for further incoming messages.
As an example, here is a simple Scala actor implementing a checksum calculator service:
actor { var sum = 0 loop { receive { case Data(bytes) => sum += hash(bytes) case GetSum(requester) => requester ! sum } } }This actor first defines a local variable named
sumwith initial value zero. It then repeatedly waits in a loop for messages, using a
receivestatement. If it receives a
Datamessage, it adds a hash of the sent
bytesto the
sumvariable. If it receives a
GetSummessage, it sends the current value of
sumback to the
requesterusing the message send
requester ! sum. The
requesterfield is embedded in the
GetSummessage; it refers usually to the actor that made the request.
We don’t expect you to understand fully the actor example at this point.
Rather, what’s significant about this example for the topic of scalability is that
neither
actor nor
loop nor
receive nor message send
(!)
are built-in operations in Scala. Even though
actor,
loop and
receive look and act very similar to control constructs
like while or for loops, they are in fact methods defined in Scala’s actors
library. Likewise, even though
(!) looks like a built-in operator,
it too is just a method defined in the actors library. All four of
these constructs are completely independent of the Scala language.
The
receive block and send
(!) syntax look in Scala much like
they look in Erlang, but in Erlang, these constructs are built into
the language. Scala also implements most of Erlang’s other concurrent
programming constructs, such as monitoring failed actors and
time-outs. All in all, actors have turned out to be a very pleasant
means for expressing concurrent and distributed computations.
Even though they are defined in a library, actors feel like an integral part of the Scala language.
This example illustrates that you can “grow” the Scala language in new directions even as specialized as concurrent programming. To be sure, you need good architects and programmers to do this. But the crucial thing is that it is feasible—you can design and implement abstractions in Scala that address radically new application domains, yet still feel like native language support.
Scalability is influenced by many factors, ranging from syntax details to component abstraction constructs. If we were forced to name just one aspect of Scala that helps scalability, we’d pick its combination of object-oriented and functional programming (well, we cheated, that’s really two aspects, but they are intertwined).
Scala goes further than all other well-known languages in fusing object-oriented and functional programming into a uniform language design. For instance, where other languages might have objects and functions as two different concepts, in Scala a function value is an object. Function types are classes that can be inherited by subclasses. This might seem nothing more than an academic nicety, but it has deep consequences for scalability. In fact the actor concept shown previously could not have been implemented without this unification of functions and objects.
Object-oriented programming has been immensely successful. Starting from Simula in the mid-60’s and Smalltalk in the 70’s, it is now available in more languages than not. In some domains objects have taken over completely. While there is not a precise definition of what object-oriented means, there is clearly something about objects that appeals to programmers.
In principle, the motivation for object-oriented programming is very simple: all but the most trivial programs need some sort of structure. The most straightforward way to do this is to put data and operations into some form of containers. The great idea of object-oriented programming is to make these containers fully general, so that they can contain operations as well as data, and that they are themselves values that can be stored in other containers, or passed as parameters to operations. Such containers are called objects. Alan Kay, the inventor of Smalltalk, remarked that in this way the simplest object has the same construction principle as a full computer: it combines data with operations under a formalized interface.5 So objects have a lot to do with language scalability: the same techniques apply to the construction of small as well as large programs.
Even though object-oriented programming has been mainstream for a long time, there are relatively few languages that have followed Smalltalk in pushing this construction principle to its logical conclusion. For instance, many languages admit values that are not objects, such as the primitive values in Java. Or they allow static fields and methods that are not members of any object. These deviations from the pure idea of object-oriented programming look quite harmless at first, but they have an annoying tendency to complicate things and limit scalability.
By contrast, Scala is an object-oriented language in pure form: every
value is an object and every operation is a method call. For example,
when you say
1 + 2 in Scala, you are actually invoking a method
named
+ defined in class
Int. You can define methods with operator-like names that
clients of your API can then use in operator notation. This is how
the designer of Scala’s actors API enabled you to use expressions such
as
requester ! sum shown in the previous example:
(!) is a
method of the
Actor class.
Scala is more advanced than most other languages when it comes to composing objects. An example is Scala’s traits. Traits are like interfaces in Java, but they can also have method implementations and even fields. Objects are constructed by mixin composition, which takes the definitions of a class and adds the definitions of a number of traits to it. In this way, different aspects of classes can be encapsulated in different traits. This looks a bit like multiple inheritance, but is different when it comes to the details. Unlike a class, a trait can add some new functionality to an unspecified superclass. This makes traits more “pluggable” than classes. In particular, it avoids the classical “diamond inheritance” problems of multiple inheritance, which arise when the same class is inherited via several different paths.
In addition to being a pure object-oriented language, Scala is also a full-blown functional language. The ideas of functional programming are older than (electronic) computers. Their foundation was laid in Alonzo Church’s lambda calculus, which he developed in the 1930s. The first functional programming language was Lisp, which dates from the late 50s. Other popular functional languages are Scheme, SML, Erlang, Haskell, OCaml, and F\#. For a long time, functional programming has been a bit on the sidelines, popular in academia, but not that widely used in industry. However, recent years have seen an increased interest in functional programming languages and techniques.
Functional programming is guided by two main ideas. The first idea is
that functions are first-class values. In a functional language, a
function is a value of the same status as, say, an integer or a
string. You can pass functions as arguments to other functions, return
them as results from functions, or store them in variables. You can
also define a function inside another function, just as you can define
an integer value inside a function. And you can define functions
without giving them a name, sprinkling your code with function
literals as easily as you might write
integer literals like
42.
Functions that are first-class values provide a convenient means for
abstracting over operations and creating new control structures. This
generalization of functions provides great expressiveness, which often
leads to very legible and concise programs. It also plays an important
role for scalability. As an example, the
receive construct
shown previously in the actor example is an invocation of a method
that takes a function as argument. The code inside the
receive
construct is a function that is passed unexecuted into the
receive
method.
In most traditional languages, by contrast, functions are not values. Languages that do have function values often relegate them to second-class status. For example, the function pointers of C and C++ do not have the same status as non-functional values in those languages: function pointers can only refer to global functions, they do not give you the possibility to define first-class nested functions that refer to some values in their environment. Nor do they provide the possibility to define name-less function literals.
The second main idea of functional programming is that the operations
of a program should map input values to output values rather than
change data in place. To see the difference, consider the
implementation of strings in Ruby and in Java. In Ruby, a string is
an array of characters. Characters in a string can be changed
individually. For instance you can change a semicolon character in a
string to a period inside the same string object. In Java
and Scala, on the other hand, a string is a sequence of characters in
the mathematical sense. Replacing a character in a string using an
expression like
s.replace(';', '.') yields a new string object,
which is different from
s. Another way of expressing this is that
strings are immutable in Java whereas they are mutable in Ruby. So
looking at just strings, Java is a functional language, whereas Ruby
is not. Immutable data structures are one of the cornerstones of
functional programming. The Scala libraries define many more
immutable data types on top of those found in the Java APIs. For
instance, Scala has immutable lists, tuples, maps, and sets.
Another way of stating this second idea of functional programming is
that methods should not have any side effects. They should
communicate with their environment only by taking arguments and
returning results. For instance, the
replace method in Java’s
String class fits this description. It takes a string and two
characters and yields a new string where all occurrences of one
character are replaced by the other. There is no other effect of
calling
replace. Methods like
replace are called
referentially transparent.
Functional languages encourage immutable data structures and referentially transparent methods. Some functional languages even require them. Scala gives you a choice. When you want to, you can write in an imperative style, which is what programming with mutable data and side effects is called. But Scala generally makes it easy to avoid imperative constructs when you want, because good functional alternatives exist.
Is Scala for you? You will have to see and decide for yourself. We have found that there are actually many reasons besides scalability to like programming in Scala. Four of the most important aspects will be discussed in this section: compatibility, brevity, high-level abstractions, and advanced static typing.
Scala doesn’t require you to leap backwards off the Java platform to step forward from the Java language. It allows you to add value to existing code—to build on what you already have—because it was designed for seamless interoperability with Java.6 Scala programs compile to JVM bytecodes. Their run-time performance is usually on par with Java programs. Scala code can call Java methods, access Java fields, inherit from Java classes, and implement Java interfaces. None of this requires special syntax, explicit interface descriptions, or glue code. In fact, almost all Scala code makes heavy use of Java libraries, often without programmers being aware of this fact.
Another aspect of full interoperability is that Scala heavily re-uses
Java types. Scala’s
Ints are represented as Java primitive
integers of type
int,
Floats are represented as
floats,
Booleans as
booleans, and so on. Scala arrays are mapped to
Java arrays. Scala also re-uses many of the standard Java library
types. For instance, the type of a string literal
"abc" in Scala is
java.lang.String, and a thrown exception must be a subclass of
java.lang.Throwable.
Scala not only re-uses Java’s types, but also “dresses them up” to
make them nicer. For instance, Scala’s strings support methods like
toInt or
toFloat, which convert the string to an integer or
floating-point number. So you can write
str.toInt as a shorter
alternative for
Integer.parseInt(str). How can this be achieved
without breaking interoperability? Java’s
String class certainly
has no
toInt method! In fact, Scala has a very general solution to
solve this tension between advanced library design and
interoperability. Scala lets you define implicit conversions,
which are always applied when types would not normally match up, or
when non-existing members are selected. In the case above, when
looking for a
toInt method on a string, the Scala compiler will
find no such member of class
String, but it will find an implicit
conversion that converts a Java
String to an instance of the Scala
class
RichString, which does define such a member. The conversion
will then be applied implicitly before performing the
toInt
operation.
Scala code can also be invoked from Java code. This is sometimes a bit more subtle, because Scala is a richer language than Java, so some of Scala’s more advanced features need to be encoded before they can be mapped to Java. Chapter 29, “Combining Java and Scala,” explains the details.
Scala programs tend to be short. Scala programmers have reported reductions in number of lines of up to a factor of ten compared to Java. These might be extreme cases. A more conservative estimate would be that a typical Scala program should have about half the number of lines of the same program written in Java. Fewer lines of code mean not only less typing, but also less effort at reading and understanding programs and fewer possibilities of defects. There are several factors that contribute to this reduction in lines of code.
First, Scala’s syntax avoids some of the boilerplate that burdens Java programs. For instance, semicolons are optional in Scala and are usually left out. There are also several other areas where Scala’s syntax is less noisy. As an example, compare how you write classes and constructors in Java and Scala. In Java, a class with a constructor often looks like this:
// this is Java class MyClass { private int index; private String name; public MyClass(int index, String name) { this.index = index; this.name = name; } }In Scala, you would likely write this instead:
class MyClass(index: Int, name: String) {}Given this code, the Scala compiler will produce a class that has two private instance variables, an
Intnamed
indexand a
Stringnamed
name, and a constructor that takes initial values for those variables as parameters. The code of this constructor will initialize the two instance variables with the values passed as parameters. In short, you get essentially the same functionality as the more verbose Java version.7 The Scala class is quicker to write, easier to read, and most importantly, less error prone than the Java class.
Scala’s type inference is another factor that contributes to its conciseness. Repetitive type information can be left out, so programs become less cluttered and more readable.
But probably the most important key to compact code is code you don’t have to write because it is done in a library for you. Scala gives you many tools to define powerful libraries that let you capture and factor out common behavior. For instance, different aspects of library classes can be separated out into traits, which can then be mixed together in flexible ways. Or, library methods can be parameterized with operations, which lets you define constructs that are, in effect, your own control structures. Together, these constructs allow the definition of libraries that are both high-level and flexible to use.
Programmers are constantly grappling with complexity. To program productively, you must understand the code on which you are working. Overly complex code has been the downfall of many a software project. Unfortunately, important software usually has complex requirements. Such complexity can’t be avoided; it must instead be managed.
Scala helps you manage complexity by letting you raise
the level of abstraction in the interfaces you design and use. As an
example, imagine you have a
String variable
name, and you want
to find out whether or not that
String contains an upper case
character. In Java, you might write this:
// this is Java boolean nameHasUpperCase = false; for (int i = 0; i < name.length(); ++i) { if (Character.isUpperCase(name.charAt(i))) { nameHasUpperCase = true; break; } }Whereas in Scala, you could write this:
val nameHasUpperCase = name.exists(_.isUpperCase)The Java code treats strings as low-level entities that are stepped through character by character in a loop. The Scala code treats the same strings as higher-level sequences of characters that can be queried with \glspl{predicate}. Clearly the Scala code is much shorter and—for trained eyes—easier to understand than the Java code. So the Scala code weighs less heavily on the total complexity budget. It also gives you less opportunity to make mistakes.
The predicate,
_.isUpperCase, is an example of a function literal in Scala.8
It describes a function that takes a character argument (represented
by the underscore character), and tests whether it is an upper case
letter.9
In principle, such control abstractions are possible in Java as
well. You’d need to define an interface that contains a method with
the abstracted functionality. For instance, if you wanted to support
querying over strings, you might invent an interface
CharacterProperty with a single method
hasProperty:
// this is Java interface CharacterProperty { boolean hasProperty(char ch); }
With that interface you can formulate a method
exists in Java:
It takes a string and a
CharacterProperty and returns true if there is a character
in the string that satisfies the property. You could then invoke
exists as follows:
// this is Java exists(name, new CharacterProperty { boolean hasProperty(char ch) { return Character.isUpperCase(ch); } });However, all this feels rather heavy. So heavy, in fact, that most Java programmers would not bother. They would just write out the loops and live with the increased complexity in their code. On the other hand, function literals in Scala are really lightweight, so they are used frequently. As you get to know Scala better you’ll find more and more opportunities to define and use your own control abstractions. You’ll find that this helps avoid code duplication and thus keeps your programs shorter and clearer.
A static type system classifies variables and expressions according to the kinds of values they hold and compute. Scala stands out as a language with a very advanced static type system. Starting from a system of nested class types much like Java’s, it allows you to parameterize types with generics, to combine types using intersections, and to hide details of types using abstract types.10 These give a strong foundation for building and composing your own types, so that you can design interfaces that are at the same time safe and flexible to use.
If you like dynamic languages such as Perl, Python, Ruby, or Groovy, you might find it a bit strange that Scala’s static type system is listed as one of its strong points. After all, the absence of a static type system has been cited by some as a major advantage of dynamic languages. The most common arguments against static types are that they make programs too verbose, prevent programmers from expressing themselves as they wish, and make impossible certain patterns of dynamic modifications of software systems. However, often these arguments do not go against the idea of static types in general, but against specific type systems, which are perceived to be too verbose or too inflexible. For instance, Alan Kay, the inventor of the Smalltalk language, once remarked: “I’m not against types, but I don’t know of any type systems that aren’t a complete pain, so I still like dynamic typing.”11
We’ll hope to convince you in this book that Scala’s type system is far from being a “complete pain.” In fact, it addresses nicely two of the usual concerns about static typing: verbosity is avoided through type inference and flexibility is gained through pattern matching and several new ways to write and compose types. With these impediments out of the way, the classical benefits of static type systems can be better appreciated. Among the most important of these benefits are verifiable properties of program abstractions, safe refactorings, and better documentation.
Verifiable properties. Static type systems can prove the absence of certain run-time errors. For instance, they can prove properties like: booleans are never added to integers, private variables are not accessed from outside their class, functions are applied to the right number of arguments, only strings are ever added to a set of strings.
Other kinds of errors are not detected by today’s static type systems. For instance, they will usually not detect array bounds violations, non-terminating functions, or divisions by zero. They will also not detect that your program does not conform to its specification (assuming there is a spec, that is!). Static type systems have therefore been dismissed by some as not being very useful. The argument goes that since such type systems can only detect simple errors, whereas unit tests provide more extensive coverage, why bother with static types at all? We believe that these arguments miss the point. Although a static type system certainly cannot replace unit testing, it can reduce the number of unit tests needed by taking care of some properties that would otherwise need to be tested. Likewise, unit testing can not replace static typing. After all, as Edsger Dijkstra said, testing can only prove the presence of errors, never their absence. So the guarantees that static typing gives may be simple, but they are real guarantees of a form no amount of testing can deliver.
Safe refactorings. A static type system provides a safety net that lets you make changes to a codebase with a high degree of confidence. Consider for instance a refactoring that adds an additional parameter to a method. In a statically typed language you can do the change, re-compile your system and simply fix all lines that cause a type error. Once you have finished with this, you are sure to have found all places that needed to be changed. The same holds for many other simple refactorings like changing a method name, or moving methods from one class to another. In all cases a static type check will provide enough assurance that the new system works just like the old one.
Documentation. Static types are program documentation that is checked by the compiler for correctness. Unlike a normal comment, a type annotation can never be out of date (at least not if the source file that contains it has recently passed a compiler). Furthermore, compilers and integrated development environments can make use of type annotations to provide better context help. For instance, an integrated development environment can display all the members available for a selection by determining the static type of the expression on which the selection is made and looking up all members of that type.\bigskip
\noindent Even though static types are generally useful for program documentation, they can sometimes be annoying when they clutter the program. Typically, useful documentation is what readers of a program cannot easily derive themselves. In a method definition like
def f(x: String) = ...it’s useful to know that
f’s argument should be a
String. On the other hand, at least one of the two annotations in the following example is annoying:
val x: HashMap[Int, String] = new HashMap[Int, String]()Clearly, it should be enough to say just once that
xis a
HashMapwith
Ints as keys and
Strings as values; there is no need to repeat the same phrase twice.
Scala has a very sophisticated type inference system that lets you omit almost all type information that’s usually considered as annoying. In the example above, the following two less annoying alternatives would work as well.
val x = new HashMap[Int, String]() val x: Map[Int, String] = new HashMap()Type inference in Scala can go quite far. In fact, it’s not uncommon for user code to have no explicit types at all. Therefore, Scala programs often look a bit like programs written in a dynamically typed scripting language. This holds particularly for client application code, which glues together pre-written library components. It’s less true for the library components themselves, because these often employ fairly sophisticated types to allow flexible usage patterns. This is only natural. After all, the type signatures of the members that make up the interface of a re-usable component should be explicitly given, because they constitute an essential part of the contract between the component and its clients.
Scala’s design has been influenced by many programming languages and ideas in programming language research. In fact, only a few features of Scala are genuinely new; most have been already applied in some form in other languages. Scala’s innovations come primarily from how its constructs are put together. In this section, we list the main influences on Scala’s design. The list cannot be exhaustive—there are simply too many smart ideas around in programming language design to enumerate them all here.
At the surface level, Scala adopts a large part of the syntax of Java and C\#, which in turn borrowed most of their syntactic conventions from C and C++. Expressions, statements and blocks are mostly as in Java, as is the syntax of classes, packages and imports.12 Besides syntax, Scala adopts other elements of Java, such as its basic types, its class libraries, and its execution model.
Scala also owes much to other languages. Its uniform object model was pioneered by Smalltalk and taken up subsequently by Ruby. Its idea of universal nesting (almost every construct in Scala can be nested inside any other construct) is also present in Algol, Simula, and, more recently in Beta and gbeta. Its uniform access principle for method invocation and field selection comes from Eiffel. Its approach to functional programming is quite similar in spirit to the ML family of languages, which has SML, OCaml, and F\# as prominent members. Many higher-order functions in Scala’s standard library are also present in ML or Haskell. Scala’s implicit parameters were motivated by Haskell’s type classes; they achieve analogous results in a more classical object-oriented setting. Scala’s actor-based concurrency library was heavily inspired by Erlang.
Scala is not the first language to emphasize scalability and extensibility. The historic root of extensible languages that can span different application areas is Peter Landin’s 1966 paper “The Next 700 Programming Languages.”13 (The language described in this paper, Iswim, stands beside Lisp as one of the pioneering functional languages.) The specific idea of treating an infix operator as a function can be traced back to Iswim and Smalltalk. Another important idea is to permit a function literal (or block) as a parameter, which enables libraries to define control structures. Again, this goes back to Iswim and Smalltalk. Smalltalk and Lisp have both a flexible syntax that has been applied extensively for building embedded domain-specific languages. C++ is another scalable language that can be adapted and extended through operator overloading and its template system; compared to Scala it is built on a lower-level, more systems-oriented core.
Scala is also not the first language to integrate functional and object-oriented programming, although it probably goes furthest in this direction. Other languages that have integrated some elements of functional programming into OOP include Ruby, Smalltalk, and Python. On the Java platform, Pizza, Nice, and Multi-Java have all extended a Java-like core with functional ideas. There are also primarily functional languages that have acquired an object system; examples are OCaml, F\#, and PLT-Scheme.
Scala has also contributed some innovations to the field of programming languages. For instance, its abstract types provide a more object-oriented alternative to generic types, its traits allow for flexible component assembly, and its extractors provide a representation-independent way to do pattern matching. These innovations have been presented in papers at programming language conferences in recent years.14, 15, 16
In this chapter, we gave you a glimpse of what Scala is and how it might help you in your programming. To be sure, Scala is not a silver bullet that will magically make you more productive. To advance, you will need to apply Scala artfully, and that will require some learning and practice. If you’re coming to Scala from Java, the most challenging aspects of learning Scala may involve Scala’s type system (which is richer than Java’s) and its support for functional programming. The goal of this book is to guide you gently up Scala’s learning curve, one step at a time. We think you’ll find it a rewarding intellectual experience that will expand your horizons and make you think differently about program design. Hopefully, you will also gain pleasure and inspiration from programming in Scala.
Have a question or opinion about Scala? Discuss this article in the Articles Forum topic, Scala: A Scalable Language.
1. Eric Raymond, The Cathedral and the Bazaar: Musings on Linux and Open Source by an Accidental Revolutionary, O’Reilly, 1999.
2. Guy L. Steele, Jr., “Growing a Language,” Higher-Order and Symbolic Computation, 12:221-223, 1999. Transcript of a talk given at OOPSLA 1998.
3.
factorial(x), or
x! in mathematical notation, is the result of computing
1 * 2 * ... * x, with
0! defined to be
1.
4. Scala comes with a standard library, some of which will be covered in this book. For more information, you can also consult the library’s scaladoc documentation, which is available in the distribution and online at.
5. Alan Kay, “The Early History of Smalltalk,” In History of programming languages—II, pages 511-598. ACM, New York, NY, USA, 1996.
6. There is also a Scala variant that runs on the .NET platform, but the JVM variant currently has better support.
7. The only real difference is that the instance variables produced in the Scala case will be final. You’ll learn how to make them non-final in Chapter 10, “Composition and Inheritance.”
8. A function literal
can be called a predicate if its result type is
Boolean.
9. This use of the underscore as a placeholder for arguments is described in Chapter 8, “Functions and Closures.”
10. Generics are discussed in Chapter 19, “Type Parameterization,” intersections in Chapter 12, “Traits,” and abstract types in Chapter 20, “Abstract Members.”
11. Alan Kay made this statement in an email in which he gave a definition of “object-oriented programming,”
12. The
major deviation from Java concerns the syntax for type annotations—it’s
“
variable: Type” instead of “
Type variable” in
Java. Scala’s postfix type syntax resembles Pascal, Modula-2, or
Eiffel. The main reason for this deviation has to do with type
inference, which often lets you omit the type of a variable or the
return type of a method. Using the “
variable: Type” syntax
this is easy—just leave out the colon and the type. But in C-style
“
Type variable” syntax you cannot simply leave off the type—there
would be no marker to start the definition anymore. You’d need
some alternative keyword to be a placeholder for a missing type (C#
3.0, which does some type inference, uses
var for this
purpose). Such an alternative keyword feels more ad-hoc and less
regular than Scala’s approach.
13. Peter J. Landin, “The Next 700 Programming Languages,” Communications of the ACM, 9(3):157-166, 1966.
14. Martin Odersky, Vincent Cremet, Christine Röckl, and Matthias Zenger. “A Nominal Theory of Objects with Dependent Types.” In Proc. ECOOP’03, Springer LNCS, pages 201-225. July 2003.
15. Martin Odersky and Matthias Zenger. “Scalable Component Abstractions.” In Proceedings of OOPSLA, pages 41-58. October 2005.
16. Emir, Burak, Martin Odersky, and John Williams. “Matching Objects With Patterns.” In Proc. ECOOP, Springer LNCS, pages 273-295. July 2007.
The Scala programming language home page is at:
This article is based on Chapter 1 of Programming in Scala, available in PrePrint form here:
The Scala mailing lists:
ScalaTest is a tool for testing Scala and Java code:
The lift Web Framework runs inside a Java web container and uses Scala for coding: live in Atlanta with two cats, a chihuahua, and a turtle.. Bill is also the lead developer and designer of ScalaTest, an open source testing tool for Scala and Java developers. | http://www.artima.com/scalazine/articles/scalable-language.html | CC-MAIN-2015-27 | refinedweb | 6,779 | 54.32 |
Opened 5 years ago
Closed 4 years ago
#13908 closed Bug (duplicate)
contrib.sitemaps.view.index doesn't work in more than one location
Description
The sitemaps app doesn't seem to allow "index" sitemaps with pagination in more than one location. For instance, if two different apps try to create an index site at two different urls, one set of urls will overwrite the other. I've created a demonstration app that shows the problem on Github. You can find it here.
Maybe it's a dumb idea to have two different sitemaps like that, but I'm not sure it's the intention of the app to act that way. If there's a way to override things and sort it out, allow me to apologize in advance.
Attachments (1)
Change History (8)
Changed 5 years ago by palewire
comment:1 Changed 5 years ago by palewire
- Has patch set
- Needs documentation unset
- Needs tests unset
- Patch needs improvement unset
- Version changed from 1.1 to SVN
I just added a patch that adds and optional kwarg where you can override the urlname that the view now reverses by default. So, if you wanted to use multiple index+section combinations across your site, you could pull it off by adding that kwarg to your index url. Like so:
from app1.sitemaps import FakeSitemap from django.conf.urls.defaults import * # Sitemaps sitemaps = { 'fake': FakeSitemap, } urlpatterns = patterns('django.contrib.sitemaps.views', url(r'^sitemap\.xml$', 'index', { 'sitemaps': sitemaps, 'section_urlname': 'app1-sitemap-section', }, name='app1-sitemap'), url(r'^sitemap-(?P<section>.+)\.xml$', 'sitemap', { 'sitemaps': sitemaps }, name='app1-sitemap-section'), )
comment:2 Changed 5 years ago by mlavin
- Needs documentation set
- Needs tests set
- Owner changed from nobody to mlavin
- Status changed from new to assigned
I have verified the issue (using [13713]) from the sample project . I would say this is a valid bug as the sitemaps specification clearly states that you can have more than one sitemap index:
If you do provide multiple Sitemaps, you should then list each Sitemap file in a Sitemap index file. Sitemap index files may not list more than 50.
However this patch needs some work. There are no tests and the new keyword argument is undocumented.
comment:3 Changed 5 years ago by mlavin
- Owner changed from mlavin to nobody
- Status changed from assigned to new
- Triage Stage changed from Unreviewed to Accepted
comment:4 Changed 4 years ago by gabrielhurley
- Component changed from Contrib apps to contrib.sitemaps
comment:5 Changed 4 years ago by graham_king
- Severity set to Normal
- Type set to Bug
comment:6 Changed 4 years ago by jezdez
- Easy pickings unset
- UI/UX unset
comment:7 Changed 4 years ago by jezdez
- Resolution set to duplicate
- Status changed from new to closed
Add optional kwarg for 'section_urlname' | https://code.djangoproject.com/ticket/13908 | CC-MAIN-2015-18 | refinedweb | 468 | 67.89 |
I once worked in a company that sells health-care devices and I've knowledge of how blood pressure monitors work. In this project I will use a micro pressure sensor to detect Korotkoff sounds, which will help me to calculate systolic (maximum) and diastolic (minimum) blood pressure. There is another method called the oscillometric and I will not use it because I don't have enough hardware and time to finish it. However the oscillometric method is based on the Korotkoff sounds and each manufacturer develops its own mathematical algorithm to find systolic and diastolic pressures. Reference:
I can tell you that the project that was made with GNAT Programming Studio is my own and my creativity (source code, schematic diagram and flowchart). For the rest, I used and modified the arduino demo code from the pressure sensor manufacturer, and the code to send the test data to excel. Let's get started with the list of necessary hardware.
Korotkoff sounds are the sounds that medical personnel listen for when they are taking blood pressure using a non-invasive procedure. They're named after Dr. Nikolai Korotkoff, a Russian physician who discovered them in 1905, when he was working at the Imperial Medical Academy in St. Petersburg, Russian...
Eventually, as the pressure in the cuff drops further, the sounds change in quality, then become muted, and finally disappear altogether. This occurs because, as the pressure in the cuff drops below the diastolic blood pressure.
There're five Korotkoff sounds:
- Phase I—The first appearance of faint, repetitive, clear tapping sounds which gradually increase in intensity for at least two consecutive beats is the systolic blood pressure.
- Phase II—A brief period may follow during which the sounds soften and acquire a swishing quality.
- Phase III—The return of sharper sounds, which become crisper to regain, or even exceed, the intensity of phase I sounds.
- Phase IV—The distinct abrupt muffling of sounds, which become soft and blowing in quality.
- Phase V—The point at which all sounds finally disappear completely is the diastolic pressure.
Traditionally, the systolic blood pressure is taken to be the pressure at which the first Korotkoff sound is first heard and the diastolic blood pressure is the pressure at which the fourth Korotkoff sound is just barely audible. However, there has recently been a move towards the use of the fifth Korotkoff sound.
Reference:
The SparkFun Qwiic MicroPressure Sensor is a miniature breakout equipped with Honeywell's 25 psi piezoresistive silicon pressure sensor. This MicroPressure Sensor offers a calibrated and compensated pressure sensing range of 60 mbar to 2.5 bar, easy to read 24 bit digital I2C output.
Each Qwiic MicroPressure Sensor has a calibrated pressure sensing range from 1 - 25 psi (52 - 1293 mmHg) and a power consumption rate as low as 0.01 mW typ. average power, 1 Hz measurement frequency for ultimate portability. Used in multiple medical (blood pressure monitoring, negative pressure wound therapy), industrial (air braking systems, gas and water meters), and consumer uses (coffee machines, humidifiers, air beds, washing machines, dishwashers).
Reference:
I bought this sensor two months ago, the libraries are made to work in the Arduino IDE. So I used the demo example and modified it to convert the pressure data into mmHg, remove the atmospheric pressure component, and send the data to the output of the DAC_1 (analog digital converter), on pin D25 of the ESP32-WROOM-32 board every 200 ms.
There're 2 channel 8 bit DACs in the ESP32 to convert the digital signals into analog voltage signal outputs. So value 1 corresponds to 11.76 mV, value 2 corresponds to 23.53 mV ... and value 255 corresponds to 3000 mV. You can download the code in the download section as pressure_sensor.ino.
5. GPS Project5. GPS Project
#include<Wire.h>
#include <SparkFun_MicroPressure.h>
SparkFun_MicroPressure mpr; // Use default values with reset and EOC pins unused
#define DAC2 26
float min_pressure = 600;
void setup() {
// Initalize UART, I2C bus, and connect to the micropressure sensor
Serial.begin(9600);
Wire.begin();
if(!mpr.begin())
{
Serial.println("Cannot connect to MicroPressure sensor.");
while(1);
}
}
void loop() {
float sensor_pressure = (mpr.readPressure(INHG)*25.4);
if(sensor_pressure<min_pressure){
Serial.println("new minimum pressure");
min_pressure=sensor_pressure;
}
sensor_pressure = (mpr.readPressure(INHG)*25.4);
int pressure_total = sensor_pressure - min_pressure;
dacWrite(DAC2, pressure_total);
Serial.print(pressure_total);
Serial.println(";");
delay(200);
}
The STM32F429I board was programmed with GNAT Programming Studio 19.1 Developed by AdaCore. This part develops the most important control function of the system and I will detail below. The schematic diagram and the flowchart you can get at the end of this tutorial. As a reference for this project, I've used the following Ada tools:
- 1) examples such as demo_adc_polling, and demo_gpio_direct_leds;
- 2) Ada drivers libraries like STM32.User_Button, STM32.ADC, STM32.GPIO, and LCD_Std_Out; and
- 3) Theory sucha as arrays, and for and while loops.
The analysis of the code of the digital blood pressure monitor I've divided it into three sections:
- Inflation of the cuff,
- Deflation of the cuff, and
- Calculation of the Korotkoff sounds.
Our schematic diagram is shown below:
- The analog port PA5 of the STM32F429I board is connected to the DAC_1 port of the ESP32-WROOM-32 board, so we will monitoring each mmHg of the pressure sensor in real time.
- When we press the user button (blue) that corresponds to port PA0, then the air pump and the pneumatic solenoid valve are turned ON.
- In this solenoid the valve closes and doesn't allow any air leakage, so the air pump begins to inflate the cuff, and the pressure sensor tells us how the pressure increases inside the cuff.
- Each increase in pressure within the cuff is printed on the LCD screen of the STM32F429I board.
- You have to note that before printing the total pressure I do a subtraction of eight units, this is because I found a small error of + 8 mmHg approx in all my readings. I did this verification with an aneroid gauge.
- When the pressure inside the cuff reaches 170 mmHg, then the air pump is stop (OFF), and the solenoid valve continues closed.
7. Deflation of the Cuff7. Deflation of the Cuff
if STM32.User_Button.Has_Been_Pressed then -- Btn pressed then go to 170 mmHg
Start_Conversion (Converter);
Poll_For_Status (Converter, Regular_Channel_Conversion_Complete, Successful);
Solenoid_valve.Set; -- solenoid valve is ON
Motor.Set; -- air pump is ON
Enable_a.Set;
Enable_b.Set;
while Pressure_total <= 170
delay until Clock + Milliseconds (75);
end loop;
Solenoid_valve.Set; -- solenoid valve is ON
Motor.Clear; -- air pump is OFF
Enable_a.Set;
Enable_b.Clear;
- Continuing with the narration from the previous section. The cuff starts to deflate from 170 mmHg.
- Remember that the solenoid valve is closed, so now the air leak is in the air release valve. Here, the recommendation is that the deflation process of the cuff is between 17 and 21 seconds. So we must calibrate this air release valve with a flat screwdriver, so if we turn it clockwise then the valve closes, and counterclockwise the valve opens.
- The next step is to measure blood pressure values between 70 mmHg and 170 mmHg and save them in the "PressureArray" matrix every 200 ms approximately.
- I have programmed a maximum value of 210 mmHg in the while function in case, during the inflation of the cuff, it exceeds the limit of 170 mmHg, for example 180 mmHg.
- The values stored in the "PressureArray" matrix and per test are between 120 and 130.
8. Calculation of the Korotkoff Sounds8. Calculation of the Korotkoff Sounds
while Pressure_total > 70 and Pressure_total <= 210
PressureArray(X_Pos) := Integer (Pressure_total);
X_Pos := X_Pos + 1;
delay until Clock + Milliseconds (190);
end loop;
- We already have all the data stored in the "PressureArray" matrix. Now our goal is to find these points where the Korotkoff sounds occur.
- I did a test, send and graph to excel all the points of the curve of my blood pressure to see the points where the Korotkoff sounds occur, and this is what I saw.
Here you can get a tutorial to send the data to Excel:
And you can download my excel file at this link: Korotkoff_sounds_excel
- In the graph above I found ten Korotkoff sounds. I did an analysis and in all Korotkoff points I found the following two constants: 1) point b is greater than point a, and 2) point c is greater than point a.
- Through a for loop I'm going to go through 130 records of the "PressureArray" matrix. Next, I assign the first record to the variable "var_a", the second record to the variable "var_b" and the third record to the variable "var_c".
- If the variables "var_b"> "var_a" and "var_c"> "var_a", then I print the variable "var_b" as Korotkoff sound.
- Any other combination I only delay 1 ms. and I don't print anything.
- According to the theory read at the beginning of this tutorial (sections 2 and 3), systolic pressure is the first Korotkoff sound, and diastolic pressure is the last Korotkoff sound.
9. Assembling the device9. Assembling the device
for I in 1 .. 130 loop
var_a := UInt32(PressureArray(I));
var_b := UInt32(PressureArray(I+1));
var_c := UInt32(PressureArray(I+2));
if var_b > var_a and var_c > var_a then
Print (0, Integer (inc), var_b, " mmHg-korot");
inc := inc + 25;
delay until Clock + Milliseconds (1);
else
delay until Clock + Milliseconds (1);
end if;
end loop;
The hardware is assembled in a box for the best handling of the device, in the figure below we can see the box made with a 3D printer, and whose STL file you can get in the download section.
Next, we join the solenoid valve with the connector through which the cuff can be connected.
Now we glue these pieces with silicone over the box's groove shown in the figure below.
I have used a smaller air pump to best fit in the box. So, we join this air pump to the cuff connector with an air hose as shown in the figure below. Also we join the air release valve to the cuff connector with an air hose.
We connect the micro pressure sensor with the air pump with an air hose. Then we fix the pressure microsensor as shown in the figure below.
The next step is to fix the ESP32-WROOM-32 board as shown in the figure below.
Finally, place the STM32F429I board and the L298N driver as shown in the figure below. All electrical connections are followed as in the schematic diagram.
In the video below I show you my first tests with this health device. In the first part, we see a test where I get six Korotkoff sounds. In the second part I did a close up, so you can see the data on the LCD screen.
To increase the amount of Korotkoff sounds detected I did two things:
- The air release valve must be recalibrated, so I gave it more time so that the device had time to detect more Korotkoff sounds (Reference: second point of section 7); and
- Foam rubber must be added to the air pump to reduce device vibrations, because these vibrations induce noise in other devices.
I've getting ten Korotkoff sounds in this test, and we can see them in the figure below:
Korotkoff sounds:
- 139 mmHg
- 130 mmHg
- 127 mmHg
- 126 mmHg
- 116 mmHg
- 111 mmHg
- 109 mmHg
- 106 mmHg
- 99 mmHg
- 81 mmHg
Finally, I had check my blood pressure and compare it to the second test.
Notes:
- At that time I was suffering from a slight flu, so the values can be considered justified.
- The OMRON digital pressure gauge detects Korotkoff sounds while the cuff is inflated. My design detects Korotkoff sounds while the cuff deflates.
DATA COMPARISONS:
- My device: according to the theory seen on sections 2 and 3, my systolic pressure is 139 mmHg, and my diastolic pressure is 99 mmHg (or 81 mmHg).
- The OMRON device: it tells me that my systolic pressure is 137 mmHg, and my diastolic pressure is 95 mmHg.
To develop this project I learned that it's necessary to verify and analyze each step to follow, eg:
- Pressure measurements of this device were compared with an aneroid manometer.
- I had to calibrate the air release valve several times.
- This model can be useful for a doctor or nurse who suffers from a bad hearing, because it would be imposible to detect the Korotkoff sounds.
- In the final tests I feel satisfied with the values measured by my device when I compare it with the OMRON device.
This project is complex, so I suggest the following challenges to improve it:
- Make the pressure sensor libraries to connect it directly with the STM32F429I board;
- Another option to the previous point would be to communicate the ESP32-WROOM-32 and STM32F429I boards through the serial port;
- Calculate the heart rate from the Korotkoff sounds; and display the hart rate with the systolic and diastolic pressure on the screen;
- Develop the prototype with the oscillometric method. To achieve this, it's necessary to test with analog and/or digital bandpass filters. At the end you have to make an algorithm to combine the oscillometric method and the Korotkoff sounds.
This is how a digital blood pressure monitor is manufactured. | https://www.hackster.io/guillengap/digital-blood-pressure-monitor-bf8a32 | CC-MAIN-2021-49 | refinedweb | 2,209 | 61.06 |
current bench code for memory leaks hunting. This code
focuses on certain narrow functionality, so it is little bit easier to
find memory problems and locate them.
I have committed some fixes to the CVS for obviously wrong malloc vs.
gmalloc and free vs. gfree code which solved some reports from valgrind
(memcheck plugin) and some leaks in tests and code maintained by me.
For the first class of leaks, we simply can't use malloc/free for xpdf
related code. This includes also (maybe not obvious on the first glance)
string and stdlib functions which internally allocates memory like strdup (I
haven't find any others but it is good to emphasize that for record).
After I got clean reports for bench code I have checked also all kernel
tests and the result is very same.
This, of course, doesn't mean that kernel is mem-leaks-free maybe in some
error cases, which are not covered by our unit tests, we are leaking
something (especially for cases when we throw exceptions).
Finally, xpdf internal memory leaks detection code revealed to be very
helpfull. It requires DEBUG_MEM macro being defined during compilation
(we don't have any configure parameter for it at the moment - I can add
it if there is some interest for it - so you have to edit generated
Makefile.flags file and add it to the C_EXTRA and CXX_EXTRA variables).
I have added gMemReport to the test mail.cc. This function prints info
about all blocks which are not freed.
Especially usefull is the first (Index) row which stands for global
index (order) of the allocation. So if there are some printed values,
you simply need to put breakpoint to the gmalloc and set condition for
gMemIndex==PRINTED_INDEX. Then you can dump backtrace and see the place
which allocates and find out why it doesn't deallocate.
This way was little but faster especially when a code leaks only in some
conditions. Valgrind would simply show backtrace but no additional
context. However there one small glitch related with xpdf allocation
code. xpdf/goo/gmempp.cc code redefines new/delete operators to use
gmalloc/gfree functions in _global scope_.
This has side effected, that
mem leak tracking is also applied to the outside library code which
either have some leaks too, or the cleanup is done later then gMemReport
is called. This implies that we have also some spam in reports and it is
harder to focus on our leaks. Attached patch simply disables gmempp.cc
code. I don't want to push this patch to the CVS, though.
There is also negative side effect that we don't track possible mem
leaks coming from new/delete in xpdf or our code, but this can be nicely
handled via valgrind or by temporary enabling gmempp.cc code. I wasn't
able to come with nicer solution, because xpdf code doesn't use its own
namespace where we could simply define those operators and new/delete is
used way to much to change it to use some namespace.
Just to be sure that cpdf-smart_ptr patch set doesn't introduce new
mem-leaks regressions I have repeated all tests also with this patch-set
applied with the same result. I would like to do the same also for
malformed documents handling patchset.
--
Michal Hocko | https://sourceforge.net/p/pdfedit/mailman/pdfedit-devel/thread/20080418135833.GF3589@curandero.mameluci.net/ | CC-MAIN-2018-22 | refinedweb | 556 | 61.46 |
13 May 2008 19:19 [Source: ICIS news]
HOUSTON (ICIS news)--US aromatics markets had little to no reaction to the earthquake in southwest ?xml:namespace>
May benzene spot levels were at $4.10-4.13/gal ($1,230-1,239/tonne) FOB (free on board) HTC (
Meanwhile, May n-grade toluene spot levels held at Monday’s range of $3.69-3.73/gal FOB HTC.
For mixed xylene (MX), spot levels were said to be at $3.68-3.75/gal FOB HTC early Tuesday, a wider range from $3.69-3.73/gal FOB HTC on Monday.
“The only impact [to aromatics] I see is coming from crude and gasoline,” said a Houston-based benzene trader.
The earthquake in southwest China's Sichuan province has severely disrupted chemicals production and transport links in the region, producers and traders in Asia said. | http://www.icis.com/Articles/2008/05/13/9123584/us+aromatics+see+thin+reaction+to+chinas+quake.html | CC-MAIN-2013-20 | refinedweb | 144 | 66.74 |
Additionally, we've added the capability to link libraries at runtime, in both Windows and Mac OS X builds. A simple example for how to use this with the glewfw library is to create a header which you include instead of the glewfw.h header as follows:
#pragma onceWhen included by runtime compiled code, the library will be linked during compilation as and when required. Note that for OS X, we need to specify frameworks with "-framework [name]" and "-l[name]" where [name] is the framework or library (see ld documentation on Apple's developer site). You can link to both static and dynamic libraries this way, but the use of dynamic libraries should be preferred. With dynamic libraries only one instance will be loaded by the executable, and resources (such as graphics data) can be preserved without serialization between runtime compiles.
#include <GL/glewfw.h>
#include "RuntimeLinkLibrary.h"
#ifdef _WIN32
RUNTIME_COMPILER_LINKLIBRARY( "glewfw.lib");
RUNTIME_COMPILER_LINKLIBRARY( "opengl32.lib");
#endif
#ifdef __APPLE__
RUNTIME_COMPILER_LINKLIBRARY( "-framework glewfw");
RUNTIME_COMPILER_LINKLIBRARY( "-framework OpenGL");
#endif
Being able to use libraries is a significant improvement in functionality. For example, core rendering functionality can now be runtime compiled.
Furthermore, we've fixed up the Visual Studio property sheets so the solution will now build with Visual Studio 2012 (including the express version), though you'll need to upgrade the solution so that it uses the default VS 2012 toolset (called v110) if you want or need to. Visual Studio should prompt you to upgrade the solution when opened.
There's quite a lot more, For full list check out the commits.. | http://runtimecompiledcplusplus.blogspot.ca/2013/01/ | CC-MAIN-2018-05 | refinedweb | 261 | 53.41 |
" == David Huard <david.huard@...> writes:
David> Hi, unles I'm doing something stupid, setp is buggy.
David> I'm creating a bunch of images using imshow and I want the
David> colormap to be consistent among images. So once they're all
David> drawn, I want to uniformize the color scale. But
>>>> setp(ax.images, clim= [0,1])
David> does not work because it sets vmin to [0,1] and doesn't
David> affect vmax.
David> On the other hand,
>>>> ax.images[0].set_clim([0,1])
The latter should not work. The set_clim function in
cm.ScalarMappable has the signature
def set_clim(self, vmin=None, vmax=None):
Ie, it does not accept the sequence argument, though
ax.images[0].set_clim(*[0,1])
should work.
The setp behavior is more of a bug with set_clim than it is with setp.
For properties to work with setp, we need to have all setters work
with a single argument, and so in this we would want to support a
single non-keyword argument which is a length two sequence mean
"[vmin, vmax]"
I just committed changes to support this so if you have svn access
give it a test drive.
JDH
Hi,
unles I'm doing something stupid, setp is buggy.
I'm creating a bunch of images using imshow and I want the colormap to be
consistent among images. So once they're all drawn, I want to uniformize the
color scale. But
>>> setp(ax.images, clim= [0,1])
does not work because it sets vmin to [0,1] and doesn't affect vmax.
On the other hand,
>>> ax.images[0].set_clim([0,1])
works fine.
Should I file a ticket ?
David
In [1]: ax = axes()
In [2]: ax.imshow(rand(10,10))
Out[2]: <matplotlib.image.AxesImage instance at 0x2aaaad22a830>
In [3]: setp(ax.images, 'clim', [0,1])
---------------------------------------------------------------------------
exceptions.ValueError Traceback (most recent
call last)
/usr/local/local/local/lib/python2.4/site-packages/matplotlib/backends/backend_agg.py in
draw(self)
390
391 renderer = self.get_renderer()
--> 392 self.figure.draw(renderer)
393
394 def get_renderer(self):
/usr/local/lib/python2.4/site-packages/matplotlib/figure.py in draw(self,
renderer)
567
568 # render the axes
--> 569 for a in self.axes: a.draw(renderer)
570
571 # render the figure text
/usr/local/lib/python2.4/site-packages/matplotlib/axes.py in draw(self,
renderer, inframe)
1105 if len(self.images)<=1 or renderer.option_image_nocomposite
():
1106 for im in self.images:
-> 1107 im.draw(renderer)
1108 else:
1109 # make a composite image blending alpha
/usr/local/lib/python2.4/site-packages/matplotlib/image.py in draw(self,
renderer, *args, **kwargs)
179 def draw(self, renderer, *args, **kwargs):
180 if not self.get_visible(): return
--> 181 im = self.make_image(renderer.get_image_magnification())
182 l, b, widthDisplay, heightDisplay =
self.axes.bbox.get_bounds()
183 renderer.draw_image(l, b, im, self.axes.bbox)
/usr/local/lib/python2.4/site-packages/matplotlib/image.py in
make_image(self, magnification)
122 im.is_grayscale = False
123 else:
--> 124 x = self.to_rgba(self._A, self._alpha)
125 im = _image.fromarray(x, 0)
126 if len(self._A.shape) == 2:
/usr/local/lib/python2.4/site-packages/matplotlib/cm.py in to_rgba(self, x,
alpha)
54 if hasattr(x, 'shape') and len(x.shape)>2: return x
55 x = ma.asarray(x)
---> 56 x = self.norm(x)
57 x = self.cmap(x, alpha)
58 return x
/usr/local/lib/python2.4/site-packages/matplotlib/colors.py in
__call__(self, value, clip)
749 self.autoscale(val)
750 vmin, vmax = self.vmin, self.vmax
--> 751 if vmin > vmax:
752 raise ValueError("minvalue must be less than or equal to
maxvalue")
753 elif vmin==vmax:
ValueError: The truth value of an array with more than one element is
ambiguous. Use a.any() or a.all()
I agree to receive quotes, newsletters and other information from sourceforge.net and its partners regarding IT services and products. I understand that I can withdraw my consent at any time. Please refer to our Privacy Policy or Contact Us for more details | https://sourceforge.net/p/matplotlib/mailman/message/8931500/ | CC-MAIN-2016-30 | refinedweb | 671 | 54.18 |
It seems like the RubyMine IDE signals a warning whenever it sees a negative conditional statement. I am wondering why using negative conditional statement is bad? Is it just purely due to readability?
For example, in this code:
class Complement
def self.of_dna dna_strand
dna_array = dna_strand.chars
dna_complement = ['']
dna_structure = ['C', 'G', 'T', 'A']
dna_array.each do |strand|
unless dna_structure.include? strand
return ''
end
case strand
when "C"
dna_complement << "G"
when "G"
dna_complement << "C"
when "T"
dna_complement << "A"
when "A"
dna_complement << "U"
end
end
dna_complement.join('')
end
end
unless dna_structure.include? strand
if !(dna.strucutre.include?)
Since Ruby has not just
if, but
unless, you're encouraged to use it so long as the resulting code is clear. That is you should convert something like this:
if (!string.empty?) # ... end
Into something like this:
unless (string.empty?) # ... end
There's exceptions to this, like when you have this:
if (!string.empty?) # ... when not empty else # ... when empty (when not not empty) end
The naive approach would be to convert that to an
unless but that creates a triple negative. You're already dealing with a double here, the
else clause only happens if the string is not not empty, or arguably does not not not contain anything.
Do this instead:
if (string.empty?) # ... when empty else # ... when not empty end
There's a number of problems with the approach you're taking here, but the most grievous is that you're declaring a constant array inside your method each time the method is invoked. Since that never changes make it a constant at the top of the class level. At least:
class Complement DNA_STRUCTURE = %w[ C G A T ] end
Even better would be to use a mapping table to represent the pairings:
COMPLEMENT = { 'C' => 'G', 'G' => 'C', 'T' => 'A', 'A' => 'U' }.freeze
Now looking at your particular problem where you're trying to "invert" a given strand of characters, the tool you really want is
tr on the string itself, a method that's optimized for handling things like cyphers where there's a 1:1 mapping between characters.
Your entire function collapses to this:
def self.of_dna(strand) strand.tr('CGTA', 'GCAU') end
Now if you want to do a quick test to ensure you're actually dealing with a valid sequence:
def self.of_dna(strand) return '' unless (strand.match(/\A[CGTA]*\z/)) strand.tr('CGTA', 'GCAU') end
There's some other bad habits you're getting into here, like creating arrays to hold single characters when strings are much better at that particular task.
c = '' and then
c << 'G' would be more efficient than an array version of same, especially considering the array will hold N strings, each of which carries some overhead, and requires creating another string at the end using
join. When using Ruby try and keep the number of objects required to do your computation, temporary or otherwise, to a minimum. It's usually faster with less "garbage". | https://codedump.io/share/MfcfiwMKX4xv/1/negative-conditional-statement-in-ruby | CC-MAIN-2017-39 | refinedweb | 493 | 64 |
People who are working in Tools 8.52 or 8.53 must be familiar with the new feature called Pivot Grids. Pivot grids provide great abilities in analytics yet maintaining the simplicity. PeopleSoft Release 9.2 is all boasted with different analytic Pivot Grids delivered by PeopleSoft. Creating a Pivot Grid is also a simple task for those who are already familiar with PS Queries. To know how to create a Pivot Grid, read my previous post on the topic.
You might find Dashboards, WorkCenters, Related Actions and Pagelets as the most suited place to put a Pivot Grid. Have you ever felt like that it will be good if I could place my Pivot Grid inside a standard page I already have? If you have the same wish I have, I have something left for you. Yes, it is possible to embed a Pivot Grid inside a standard page and it is not that difficult as you might have thought. Just follow the three simple steps.
Step I: Publish the pivot grid as a pagelet. Make sure that you check the embeddable option and note down the Pagelet ID. If you missed to note the ID, you will get it from the pagelet wizard.
Step II: Create a HTML area on your standard page and assign a work record long field (say A_WRK.HTMLAREA).
Step III: On the rowinit of the work record field’s PeopleCode event write the below PeopleCode.
/* Import the Pagelet Wizard application */
import PTPPB_PAGELET:*;
Local object &PageletID;
/* Create the Pagelet Wizard */
&PGWiz = create PTPPB_PAGELET:PageletWizard();
&PageletName = "YOUR PAGELET NAME";
&Pagelet = &PGWiz.getPageletByID(&PageletName, False);
&myHTML = &Pagelet.Execute();
A_WRK.HTMLAREA.Value = "<div class=’PSTEXT’>" | &myHTML | "</div>";
If you want to pass context sensitive prompt values to the pivot grid, then you can even do that. Try and explore the class PageletWizard for more details.
hi this page was very useful, I was just wondering how to pass a prompt value to the Pivot grid automatically. (Which you have mentioned at the end to refer the class PageletWizard)
Could you please help me with the following problem.
I have a search page with the list of Emplids. When I enter the Emplid and go to Main Page it should display the data related to entered Emplid.
Main page is having the Pagelet(Pivot Grid as the data source).
But the entered Emplid is not passing into the Pivot Grid prompt.
I need to click on the prompt and enter the emplid manually to get the required data.
Can this be automated, Kindly help if anyone has come across such issue.
Thanks in Advance.
Best Regards,
Sreedhar
sreedharchalavadi@gmail.com
+91 9916959624
Hi Sreedhar,
Based on your requirement it seems that you are duplicating the Pivot Grid prompt by creating a search page for entering employee id. You could directly let the user enter the employee id on the pivot grid prompt and eliminate the duplicate search page and additional logic.
Having said that, there can be business scenarios which may force you to do so, such as displaying pivot chart along with some other component data and so on. In such cases as I have mentioned please go ahead and explore the properties available on the Pagelet and PageletWizard application classes, you will find the provision to pass the parameters there.
To start with, You can explore more on the DataSource property within the Pagelet class and further look on the ParameterCollection and its associated methods on the DataSource.
Once you drill into these classes you would be able to fetch the parameter and modify it. Do all these prior to calling the execute method. This may require some effort from your part to get it through.
If you find it difficult to deal with the pagelet classes, another alternative would be to embed the Pivot Grid component as an iFrame within the html area. But that will loose the responsive behaviour of Fluid Pivot Charts. If you want to display only the Pivot Grid on the page, then instead of embedding inside a html area, redirct the user to the pivot grid url. The steps would be
1. Generate URL for Pivot Grid Component (Menu: PTPG_WIZ_MENU Component: PTPGVIEWER).
2. Append to the URL the Pivot Grid Name ("&PGNAME=") and View Name ("&VIEWNAME=");
3. Append Prompt with the keyword Bind in the respective order ("&BIND1=BU1") and so on.
4. Now redirect or display the URL generated.
But still I recommend to use the delivered Prompt option on the pivot grid rather than doing all these. Any change in the Pivot grid rendering engine may otherwise disrupt your code.
Thanks,
Tony
Hi Tony,
Your Posts are really helpful for guys like me to learn more about PeopleSoft.
I have a question on Pivot grid.
Can you explain how to customize the delivered PS pivot grid drilldown ?
Say, if we want to adjust the column width or if we need to add hyperlinks in the drill down.
Thanks very much!
Regards,
Nahas | http://www.peoplesoftjournal.com/2013/10/embedding-pivot-grids-in-standard-pages.html | CC-MAIN-2017-39 | refinedweb | 834 | 73.27 |
SEMOP(2) System Calls Manual SEMOP(2)
NAME
semop -- semaphore operations
LIBRARY
Standard C Library (libc, -lc)
SYNOPSIS
#include <<sys/sem.h>>
int
semop(int semid, struct sembuf *sops, size_t nsops);
DESCRIPTION
semop() provides a number of atomic operations on a set of semaphores.
The semaphore set is specified by semid, sops is an array of semaphore
operations, and nsops is the number of operations in this array. The
sembuf structures in the array contain the following members:
unsigned short sem_num; /* semaphore # */
short sem_op; /* semaphore operation */
short sem_flg; /* operation flags */
Each operation (specified in sem_op) is applied to semaphore number
sem_num in the set of semaphores specified by semid. The value of sem_op
determines the action taken in the following way:
o sem_op is less than 0. The current process is blocked until the
value of the semaphore is greater than or equal to the absolute value
of sem_op. The absolute value of sem_op is then subtracted from the
value of the semaphore, and the calling process continues. Negative
values of sem_op are thus used to enter critical regions.
o sem_op is greater than 0. Its value is added to the value of the
specified semaphore. This is used to leave critical regions.
o sem_op is equal to 0. The calling process is blocked until the value
of the specified semaphore reaches 0.
The behaviour of each operation is influenced by the flags set in sem_flg
in the following way:
IPC_NOWAIT In the case where the calling process would normally block,
waiting for a semaphore to reach a certain value, IPC_NOWAIT
makes the call return immediately, returning a value of -1
and setting errno to EAGAIN.
SEM_UNDO Keep track of the changes that this call makes to the value
of a semaphore, so that they can be undone when the calling
process terminates. This is useful to prevent other
processes waiting on a semaphore to block forever, should
the process that has the semaphore locked terminate in a
critical section.
RETURN VALUES
Upon successful completion, a value of 0 is returned. Otherwise, -1 is
returned and the global variable errno is set to indicate the error.
ERRORS
semop() will fail if:
[EINVAL] There is no semaphore associated with semid.
[EIDRM] The semaphore set was removed while the process was
waiting for one of its semaphores to reach a certain
value.
[EACCES] The calling process has no permission to access the
specified semaphore set.
[E2BIG] The value of nsops is too big. The maximum is defined
as MAX_SOPS in <sys/sem.h>.
[EFBIG] sem_num in one of the sem_buf structures is less than
0, or greater than the actual number of semaphores in
the set specified by semid.
[ENOSPC] SEM_UNDO was requested, and there is not enough space
left in the kernel to store the undo information.
[EAGAIN] The requested operation can not immediately be
performed, 6.1.5 November 3, 2005 NetBSD 6.1.5 | http://modman.unixdev.net/?sektion=2&page=semop&manpath=NetBSD-6.1.5 | CC-MAIN-2017-30 | refinedweb | 485 | 62.07 |
.Random.NextDouble() seems to do inexplicable memory allocations that result in a considerable slowdown when using the Boehm garbage collector, presumably due to the global allocation lock. Running the attached code is considerably faster with --gc=sgen.
This would not be surprising if there were a memory allocation involved. Yet the NextDouble()/Sample() code should not allocate any memory at all. When creating a custom version of mcs/class/corlib/System/Random.cs in a different namespace and calling that, the speed issue disappears as soon as the first two lines of the Sample() code (which increment inext and inextp with wrap-around semantics) are removed. I would suspect a boxing/unboxing issue, except that there shouldn't be any boxing/unboxing involved.
This was observed on OS X with Mono 3.0.10 and on Linux with Mono 3.0.12.
Created attachment 4297 [details]
Sample code to replicate the issue.
There is additional System.Threading.InternalThread when running with boehm but not sure why
On my machine
Boehm: ~10secs
Sgen: ~4secs
Even if there is no allocation involved
This is due to cache effects, the Random () instances get allocated to the same cache line, so the state changes done by Random.Sample() have to be synchronized between the cores.
-> NOTABUG. | https://xamarin.github.io/bugzilla-archives/13/13136/bug.html | CC-MAIN-2019-39 | refinedweb | 212 | 56.45 |
No fluff introduction to Java
About Java
Generally, Java refers to these 3 things;
- A programming language
- A set of built-in libraries and technology frameworks
- A virtual machine. Developers affectionately refer to this as the runtime environment. You may hear some people call this by another name like JRE (Java Runtime Environment) or JVM (Java Virtual Machine). It’s all the same. In this book, I may refer to it as simply “runtime”
Some tidbits of info about Java;
- Was created by James Gosling sometime in the early 1990s
- Released by Sun Microsystems in 1995, so its’ quite long in the tooth now, but still growing strong
- Has nothing to do with JavaScript. It’s not a derivative nor a related language. Java is to JavaScript as car is to carpet. They only have common letters in their names
- In 2010, Oracle Corp. acquired Sun Microsystems,so, Java is now in the stewardship of Oracle
- The’re are implementions of the JDK and JVM other than the one from Oracle, OpenJDK is such as example; but in this book, I used Oracle JDK for all the examples. You can see all the other JVMs in here WikiPedia’s JVM list
- There are various certifications for the Java technology. If you want to know more about certifications, you can go to education.oracle.com
Java comes in various editions,
- Java SE (standard edition). Mostly used for desktop apps. This is what we’ll use for the most part of the book
- Java EE (enterprise edition). Used for building web applications, web services, high-availability back-end processes etc
- Java ME (micro edition). Used for running apps in the embedded devices. Think of IoT (internet of things)
A summary of the Java SDK versions is shown below.
A note about the JDK releases. Starting with Java 9, Oracle changed the cadence of release. It’s now on a very agressive 6-month cadence cycle. There is a good chance that by the time you read this, you’ll be using a different version of the JDK.
Should I care? Fair question. Given that there are many languages to choose from, why would you pick Java? There are many ways to answer it, one is to laboriously list the pros and cons and Java vs other languages, but that’s already done here and here, there are others but those two links should do it.
Setup
Depending on what OS you use and your preferences for editors or IDEs, there’s a couple of ways to install a Java development environment. The simplest way is to get it from Oracle site. The installer is available for Windows, Linux and macOS. You can download the currently stable version from the Oracle site, Java 11 download page. What you want to dowload is the Java Development Kit (JDK); not the JRE (Java runtime environment). You will need development kit to create Java programs.
The JDK has everything you need to write Java SE programs. All you need is a program editor or an IDE (integrated development environment). There are plenty of choices but I won’t list them here. My advice is to use whatever editor you are already using. Use the one you’re more comfortable with. Having said that, the most well-known IDEs are probably Eclipse, Netbeans and IntelliJ.
I’ve coded all the examples in the book using IntelliJ IDEA community edition. You don’t have to follow this setup, but if you want to use this, you can get it at JetBrain’s download page . It’s not difficult to install this IDE, in fact, it’s very straightforward. Download it, double-click and follow the prompts. You get to install it just like how you install your other software. It will also try to detect your JDK installation during the setup.
Basic workflow
We need some terminologies;
- JRE (Java Runtime Environment). You already know what this is, we discussed it before. You need this to run Java programs, but you cannot use this to create them. To create Java executables, you need to get the;
- JDK (Java Development Kit). This is a collection of libraries and command line tools. These are the tools you need to create Java programs
- Bytecodes are Java executable files. You run this inside the JVM
No matter what IDE or editor you choose to use, the basic steps when working with a Java program as follows;
- Write the program. Save it in file with a .java extension
- Compile it using the Java compiler (
javac), this tool turns your source file to Java bytecodes
- Run the bytecodes on a VM appropriate for your platform
The figure above shows how a Java source file is created and executed using the JDK and JRE.
- You create a source file named Hello.java
- Compile it with
javac Hello.java, this step produces the file Hello.class (this is the bytecode)
- Run the program on the JRE
java Hello
Depending on what toolchain you select, you will either be in the driver seat when these things happen or you’ll be in the passenger seat.
If you don’t use an IDE, that means you chose to work with the command line tools and and a program editor; you’ll be in the driver seat. You need to manage the compilation and execution steps by hand. If on the other hand, you chose to work with an IDE, these things are hidden from you. All you need to do is to click “Run”.
In the next section, we’ll build the actual “Hello.java” program.
Creating Project in IntelliJ
If you’re not using IntelliJ, you can skip this section entirely. Whatever tool or IDE you’re using, I suggest that you get familiar with the steps on how to create a project and/or a source file. That’s really all this section is about.
Any new development work in IntelliJ always starts by creating a project. We’ll create one now.
1) Start IntelliJ if it’s not started yet
2) If there aren’t any projects opened yet, click Create Project on the Welcome screen. Otherwise, from the main menu bar, click File > New > Project
3) In the left-hand pane, select Java
4) Specify the JDK you want to use in the project. You should be able to see the JDK 10 we downloaded earlier. Click Next
5) This next screen will ask if we want to create a project from a template. No thank you.
Don’t choose anything, just click Next
6) On the next page, specify the project name e.g. “HelloWorld”.
You can also change the project location that’s suggested by IntelliJ
7) Click Finish
Your project structure should look something like this
There are two top-level nodes;
- The Java module (HelloWorld). This is where we will work almost most of the time. The .idea folder and the HelloWorld.iml file holds the configuration data for your project and module. The src folder (short for source) is where we will store all our program source files
- External libraries. We don’t care about this one for now
Now that we have a project, we can create a source file. To create a new Java class source file, you can use the context-menu on the src folder (right-click on the src folder) then select New > Java Class. Name the new class “Hello”.
Okay. That’s all we really need to do in this chapter. We’ll write our Hello world program in the next chapter.
Hello
What we’d like to do here is simple, we want to print “Hello World” in the console. The statement that will do that is this
System.out.println("Hello World");
But we can’t just write that line in a source file, compile, then run. We need to observe some rules of the language before we can successfully run the program. The first two, among the many, Java rules that we need to learn are the following;
- If you want your program to do something productive when you run it, like print something, you need to write a main function
- Everything in Java has to be written inside a class
A program that prints “Hello World” in Java, looks like this
class Hello { // (1) public static void main(String []args) { // (2) System.out.println("Hello"); // (3) } }
(1) Think of a class as unit of organization, in the same way that a function is also a unit of orgranization. A function organizes statement by enclosing them in its body . Hence, we call a function a “named collection of statements”. A class on the other hand, is a named collection of functions and variables (properties). We’ll settle for this definition of a class, for now. We can revise the definition as we go along
(2) Ignore the words static, void and public, at least for now. The name of the function here is
main(String []args). The parameter is an array of Strings, you won’t need to bother with this parameter most of the time, so we’ll ignore it for now. A function’s name is chosen by the programmer (you), so you can name your function anything you want; but
main is a special name
(3) This is the only statement we care about. It’s the one that actually does the printing
I> Functions in Java are called methods. It’s the term tha Java developers use when they refer to functions. So, we’ll start using this term from hereon
Remember the following when you write Java programs;
- Java programs are case-sensitive, so
mainis different from
Main, the former is recognized by the runtime as a valid entry point for a program, the latter is not. Another example,
staticis different from
Static, the former is a valid Java keyword, the latter is not
- Java statements are terminated by a semi-colon. If you forget to put the semi-colon, you won’t be able to compile your codes. You’ll get errors
To run the code, go to the main menu bar, then Run > Run, as show in the picture below
You only need to do this once (per source file). IntelliJ needs to know your Run configuration. You can set it in this next screen.
Choose “Hello”. That should run it. You only have do this run configuration during the first time you will compile and run a source file. For subsequent runs, you can simply press
CTRL + R (macOS) or
Shift + F10 (Linux or Windows).
Okay. Now you know how to create a project and Java source files, you should be able to try out the coding examples.
Quick Tour of the language
Generally, Java programs are organized this way
- statements and expression are written inside methods
- methods are written inside classes
- variables can be written inside methods; in which case, they are called local variables. They can also be written inside classes (the same level as methods), in which case, they are called member variables. Some programmers call them properties (member variables). I actually like to call them properties too, it’s shorter
- properties and methods make up a class
- classes can be organized into a package. A package is just a folder that contains classes. We can call it a “named collection of classes”. Some programmers also it a namespace
Variables
You can use variables to store data, any kind of data. Working with variables generally goes like this;
- Choose the type of data. Basically, you’re deciding what kind of data this variable will store, will it be a number, String, boolean etc.
- Name the variable. It’s your responsibility to name your variables, so choose them well. There are rules to follow when naming them; we’ll get to that in a minute
- Optionally, you can assign a value to the variable
Let’s look at some examples
int somenumber; // (1) somenumber = 10; // (2) int anothernumber = 1; // (3)
(1) The name of the variable is
somenumber and its type is
int. We didn’t assign a value to it immediately. You can generally do this, you can declare them but not yet assign a value. Late initialization is mostly okay. Notice that the type (
int) is written on the left of variable name (somenumber). This is the proper way to declare a variable
(2) Here, we get to assign a value to somenumber,
10 is an integer literal, we can assign it to somenumber because it’s type is
int (an integer). If you assign a value other than an integer, like a String or a boolean, that won’t work. You’ll get an error.
(3) Here, we declare and assign a value to the variable on the same line
The type of a variable or the type of a data dictates what you can do with the variable, what kinds of operations are allowed. If it’s a numeric type, you can be sure that all the math operator will work on it. It wouldn’t make sense to use math operator on boolean types, just like it wouldn’t make sense to use boolean or logical operators on String types.
Each data type in Java responds to a defined set of operations. This is the reason why Java won’t allow you to store a String data in an int variable, for example.
int a = 10; // ok a = "10"; // not ok, compiler will complain
This is the reason why Java is called a strongly typed language. You can only set the type of a variable once; and once you did that, you cannot change it anymore. That’s strong typing.
You must have also noticed that Java forced us to declare the type of a variable even before we could do anything with it.
int mvar = 10; // ok nvar = 10 // not ok
Declaring the type of variable is not optional. Java forces us to do this so that the compiler can know what kind of data, and hence, what kind of operations are valid on the data. The compiler can catch many kinds of programmer errors if it knows the type beforehand. This is the reason Java is called a statically typed language. Static typing means that you declare the type of the variable at the same time you create the variable. It’s not the compiler’s responsibility to guess or infer what kind of data you’re using. You have to be explicit.
The language comes with 8 built-in types, they’re affectionately called primitive or native types. They’re shown in the table below.
Notice the underscores in the sample integers above? Since Java 7, you can put underscores in integer literals. It makes it easier to group large integers. You should be able to spot thousandth, hundred thousandth or millionth posistion of your literals, like this
short slimit = 32_767;
When naming your variables, best remember these rules. A variable’s name;
- Can’t start with a number. The name can include a number but it can’t start with it (mandatory)
- Can’t contain spaces or special characters (mandatory)
- Can’t be the same as a Java keyword (mandatory)
- Is descriptive. You have to be able to tell what kind of data it’s carrying just by its name (not mandatory, but good advice)
- Has good length. The name can be of any length, but just remember that you have to type it, many times over (not mandatory, but good advice)
- Can begin with an underscore or a dollar sign, but this is discouraged, so, quickly forget about this one
These rules don’t apply only to variable names. They also apply to names of classes and methods
The list of Java keyword are shown below. * not used ** added in JDK 1.2 *** added in JDK 1.4 **** added JDK 1.5
Expressions
When you combine variables, literals and operators, you get an expression. Here are some samples
1 + 2 a - 1 inches * 2.54
Expressions results to something. You can assign the result to a variable, like this
int mvar = 1 + 2;
1 + 2 is an expression, the moment you assign the result to a variable, it becomes a statement; notice the semi-colon?
Statements, unlike expressions, do not produce a result.
Statements
Statements are things that do something, like print that, assign this to that. Some examples of Java statements are shown below.
System.out.println("Hello"); // (1) int a = 1; // (2) float b = 1 + 3; // (3) double c = b + 10; // (4) float factor = 2.54; float cm = c * factor; // (5)
(1) Print something
(2) We’re assigning an
int literal to a
(3) We’re assigning the result of the math expression
1 + 3 to b
(4) Expressions can have a mix of variables and literals as an operand
(5) Sometimes, the operands in an expression are all variables
You can put comments in your code. The compiler ignores them, so it’s a good way to document your code. Java has 3 kinds of it, the single line comment, multiline comment and the Javadoc comment.
In a single line or inline comment, everything to the right of the forward slashes until the end of the line is ignored.
// single line comment
In a multiline comment, also called C-style comment, everything in between
/**/ are ignored.
/* A multi-line comment, it can span many lines */
Javadoc comment.
/** This is a Javadoc style comment. When you write your comments like this, it will be picked up by the Javadoc tool which can create HTML documentations for you */
Operators
Java operator are generally intuitive, they do what you think they do.
= This is the assignment operator. You’ve seen it before. Whatever is the RHS (right hand side) gets stored or assigned to the variable on the LHS (left hand side), for example;
boolean mvar = anothervar > 10;
+ - / * % These are the math operators. They work on numeric types (with the exception of the plus sign which also works on String types).
+ - ++ — ! These are unary operators. They’re called that because unlike the other operators (binary), these are used on a single operand. Like this
int counter = 0; counter++; // adds 1 to counter ++counter; // subtracts 1 from counter boolean marg = true; marg = !marg; // (1)
(1)
! means not. So, the initial value of marg is true;
!marg means not true, hence false. We assigning false to be the new value of marg.
== < > >= <= != These are the equality and relational operators. You use these to express equivalence of operands. An expression that uses any of these operator gives out boolean results. For example
int a = 10; int b = 11; boolean c = a > b; // false
&& || ?: & | The conditional operators works on boolean type operands.
boolean a = true; boolean b = false; boolean c = a & b; // false boolean d = a && b; // also false boolean e = a | b; // true boolean f = a || b; // also true
& This is the logical and operator. For an expression to be true, both operands have to true, since only a is true,
a & b results to false
| This is the logical or operator. For an expression to be true, only one of the operands has to be true. Since a is true, the expressions results to true.
&& This is also a logical and but this is the short-circuit version. If you use this and it detects that the first operand is already false, it won’t bother checking if the other operand is true or false. It will short-circuit the operation, and yield false. The non-short-circuit verion evaluates both operands.
|| This is also the logical or but it’s the short circuit version. If you use this, and it detects the first operand to be true, it won’t bother checking the other operand, it will short-circuit the operation and yield true. The non-short-circuit verion evaluates both operands.
Methods
Methods are a named collection of statements. They’re always written inside classes and you cannot nest them in other methods. Like variables, you get to pick their name and their type. An example of a method that returns an int is found below.
int convertInchesToCm(int inches) { return inches * 2.54; }
When a method doesn’t have to return anything, use thje
void return type, like this
void talk() { System.out.println("Hello"); }
Classes
Classes can contain method and member variables, like this
class Person { String firstname = "John"; String lastname = "Doe"; void talk() { System.out.printf("Hello %s %s", firstname, lastname); } }
There’s a lot more going with classes than what’s shown above, but we’ll get to that in a later section.
Strings
Strings are not part of Java’s built-in or primitive types, it’s a reference type. We haven’t discussed reference types yet, but we’ve been using Strings in some of our examples. We might as well learn a little bit abouth this type.
Java has a char type, if you need to work with individual characters, this is data type you wanna look at; but most of the time, we tend to work with sequences of characters and we deal with them as a bunch, rather than individually. That’s where Strings come in.
A String data type stores a sequence of individual characters using the UTF-16 encoding, so it can store pretty much anything.
You can define a String variable by enclosing a sequence of letter in double quotes, like this.
String mvar = "Hello";
You can’t use single quotes to define Strings. Java uses single quotes to define chars, not Strings.
You can add Strings using the plus sign (math addition symbol), like this
String a = "Hello"; String b = "World"; String c = a + b;
W> Combining Strings using the plus sign is not a memory-efficient way of concatenation. We’ll get back to this topic when we discuss the String class in more detail; that will be in a later chapter.
Up-casting and down-casting
You can assign a value to a variable whose type is wider than that of the value’s. This is called up-casting, and it happens automatically. For example
int ivar = 10; long lvar = ivar; // long is wider than int
The double type is widest in all numeric primitive types and byte is the narrowest type. You can think of the hierarchy this way;
double > float > long > int > short > byte. The following program illustates this point.
public class CastingSample { public static void main(String args[]) { byte b = 1; short s = b; int i = s; long l = i; float f = l; double d = f; System.out.printf("double d = %s", d); // prints 1.0 } }
Down-casting is when you assign a value to variable whose type is narrower than that of the value’s; but that does not happen automatically, unlike in up-casting. To perform a down-cast, you need to use the cast operator. Like in the following code.
long lvar = 10; int ivar = (int) lvar; // (int) is the cast operator
The cast operator needs to be at the left of the value to be casted (lvar). Put the target type inside the parentheses. In the example above, we’d like to cast lvar, which is long, to an int, hence we put the
(int) inside the parentheses. Now that lvar is an an int, we can store in in ivar which is an int.
If then statement
You can side-step some statements in your code. The if-then statement will lets you run some statements selectively. You can choose to run which statements will run depending on some conditions.
The first form of this statement looks like this
if (a > b) { System.out.printf("%s is greater than %s", a, b); }
The if statement takes a boolean expression
(a> b) and evaluates it. If it’s true, it executes all the statements in the block, as shown in the code above.
The second form of this statement looks like this
if (a > b) { System.out.printf("%s is greater than %s", a, b); } else { System.out.printf("%s is greater than %s", b, a); }
It looks straightforward doesn’ t it? If the condition
(a > b) isn’t true, then all the statements in the
else block will be executed.
The third form looks like this
import java.util.Calendar; import java.util.Date; Calendar c = Calendar.getInstance(); Date d = new Date(); c.setTime(d); int dayOfWeek = c.get(Calendar.DAY_OF_WEEK); // Next, print out friendly name for the // current day of week if (dayOfWeek == 1) { System.out.println("Sunday"); } else if (dayOfWeek == 2) { System.out.println("Monday"); } else if (dayOfWeek == 3) { System.out.println("Tuesday"); } else if (dayOfWeek == 4) { System.out.println("Wednesday"); } else if (dayOfWeek == 5) { System.out.println("Thursday"); } else if (dayOfWeek == 6) { System.out.println("Friday"); } else if (dayOfWeek == 7) { System.out.println("Saturday"); }
Don’t be bothered by the first 5 lines, we’ll get to those kinds of statements shortly. What’s important to know is that the first 5 lines simply gets the current date and puts it on Calendar object. The 6th line gets the “day of the week” value of the Calendar object. This value is an integer and the range of its possible values are 1..7; 1=Sun, 2=Mon, 3=Tue etc.
You can use the
else if clause if you need to account for multiple pathways, like the code above.
Switch statement
The switch statement has a slightly different structure from the if-then statement which makes it, in some cases, more readable than an if-else if . The basic form of the switch statement is as follows
switch(expr) { case value: statement; break; case value: statement; break; default: statement; }
Where expr is either a byte, short, char int or String type (String was added in Java 7). Let’s try it with the Calendar example.
Calendar c = Calendar.getInstance(); Date d = new Date(); c.setTime(d); int dayOfWeek = c.get(Calendar.DAY_OF_WEEK); String day = ""; switch(dayOfWeek) { case 1: day = "Sunday"; break; case 2: day = "Monday"; break; case 3: day = "Tuesday"; break; case 4: day = "Wednesday"; break; case 5: day = "Thursday"; break; case 6: day = "Friday"; break; case 7: day = "Saturday"; break; default: day = "Dunno"; } System.out.printf("Today is %s", day);
While loop
When you need to run a group of statement repeated or loop through them, you can use the
while statement. The basic form looks like this.
while (condition) { /* 1. execute some statements 2. but make sure that you do something to make the condition false at some point in time; otherwise you just keep on looping */ }
The basic is idea is that while the condition is still true, you keep on running all the statements inside the body of the loop; everything in between the pair of curly brace is the body of the loop.
int count = 0; // (1) while(count < 11) { // (2) System.out.println(count); count++; // (3) } // (4)
(1) initialize
count to 0. This is the counter variable
(2) The guard condition of the while loop is evaluated for first time, at this point, the value of the count variable is zero, the condition evaluates to true and we enter the loop’s body
(3) The
count variable is incremented using one of the shorthand operators, count is now equal to 1
(4) We reach the closing curly brace which is the end of the while loop. Program control goes back to beginning of the loop, the condition is evaluated for the second time. The count variable is still less than 11 so we enter the loop again. This will go on until the value of count will be equal to 11, at which point, we will no longer enter the body of the loop and the program control jumps to the closing curly brace; it’s the end of the loop.
Java has another variation of the while loop, it’s called the do while loop. It’s basic form as as follows.
do { statements; } while (condition)
It’s almost the same as the while loop in the do while, the statement inside the block are guaranteed to be executed at least once; it’s because the condition is checked at the tail-end of the statement. So, even if the condition is false to begin with, you would have already ran through the statements.
For loop
The for statement is another construct that you can use to loop through statements. It’s basic form is as follows.
for (init value;condition;increment/decrement) { statements; }
Where;
- init value declares or defines the initial value of variable. This variable us typically used as a counter (like count in our while loop example)
- condition is a boolean expression. The runtime evalutes this condition each time it enters the loop, as long as the condition is true, the runtime keeps on running the statments inside the block
- increment or decrement are math expressions. It typically uses the unary operator ++ or – to increase or decrease the value of a counter
Let’s see an example
for(int count = 0; count < 11; count++) { // (1)(2)(3) System.out.println(count); // (4) }
(1) A counter variable named count is initialized to zero
(2) A conditional expression (count < 11) is set to determine how many times we will go inside the loop (3) The count variable’s value is increased by 1 using one of the shorthand operators (4) Value of count is printed on the screen
There are two Java keywords that operate on loops, both the for and while loop variants. These keywords are break and continue. When they are used inside loops, they have the same effect; they both terminate the execution of the loop. They have a very slight difference, which we’ll explore now.
When you use continue in a either a while or for loop, this is what happens;
while (condition) { statement 1; statement 2; continue; statement 3; statement 4; }
When the runtime encounters the continue keyword, statements 3 and 4 will no longer be executed. The control will go back to the beginning of the loop, so you will have a chance to check if the condition on the while loop is still valid.
Let’s see what happens if we use break;
while (condition) { statement 1; statement 2; break; statement 3; statement 4; }
When the break keyword is used, statements 3 and 4 will also be ignored, just like the case in continue, but instead of going back to the beginning of the loop, the program control will transfer to the first statement after the closing curly brace.
I don’t recommend the use of break and continue because it’s much cleaner to start and end loops with respect to a condition. That’s not an absolute thing, of course there will be times when you will need to use either one of these keywords, but that should be the exception, rather than the rule.
Sample program, FizzBuzz
Let’s put our chops into practice. We’ll do two simple exercises, the fizz-buzz problem and the multiplication table problem. Very popular amongst students and beginner programmers. We’ll do the fizzbuzz first.
For the fizzbuzz program, what we want to do is this;
- count from 1 to 100
- if the value of count is exactly divisible by 3, print “fizz”
- if count is divisible by 5, print “buzz”
- if count is both divisible by both 3 and 5, print “fizzbuzz”
Let’s see how that looks in code.
class FizzBuzz { public static void main (String [] args){ for (int i = 1; i <= 100 ; i++ ) { // (1) if ( i % 15 == 0) { // (2) System.out.printf("FizzBuzz %d ", i); } else if (i % 5 == 0) { System.out.printf("Buzz %d ", i); // (3) } else if(i % 3 == 0) { // (4) System.out.printf("Fizz %d ", i); } } } }
(1) Count from 1 to 100, that’s easy enough to do with a for loop (2) Check if the current value of i is divisible by both 3 and 5, if it is, print “FizzBuzz” (3) If the number is not divisible by 3x5, is it divisible just by 3 then? If it is, print “Fizz” (4) If the number is not divisible by 3x5 and not divisible by 3, is divisible by 5? If it is, print “Buzz”. This is the last condition that we will check, because only these three conditions are stated on the problem
Sample Program, multiplication table
This is an exercise on nested loops, the goal is to output something like this
1 2 3 4 5 2 4 6 8 10 3 6 9 12 15 4 8 12 16 20 5 10 15 20 25
Let’s see how that looks in code
public class MultiplicationTable { public static void main(String []args) { int tablesize = 5; for (int i=1; i <= tablesize; i++) { for (int j=1; j <= tablesize; j++) { System.out.printf("%d\t", i * j); } System.out.println(""); } } }
To follow the code, I suggest that you try simulate this program by hand. On the first for loop write the value of the i in a piece of paper, then go to the next inner for loop and write the value of j on the same piece of paper. Then write the result of the
i * j on the same piece of paper (That simulates the printf).
Next, go back to the beginning of the inner for loop ( that’s where you go back to, not the outer for loop). Java loops, when nested, has to be resolved from inside going out. Until the inner for loop is exhausted, that’s where you go back to.
So, by now, the value of j has increased by 1 while i has stayed the same. Write down the value of i, j and their product for every iteration of the inner loop. At some point when j reaches 6, you will exit the inner loop, then encounter the closing curly brace of the outer loop, and go back to the beginning of outer loop. Now i will increase by 1. You will do this until i’s value is 6. Hopefully by then, you’ll see how the code works.
Errors and Exception Handling
You will encounter errors. That’s for sure. There are three kinds of them, compiler, runtime and logic errors. Let’s look at each one of them.
Compiler errors
This happens when you don’t follow correct syntax. That’s why this is also called syntax errors. Java is a compiled languaged, its compiler checks your code against some set of rules. If your code violate some rules, like, forgetting the semi-colon, misspelling some keywords, referring to a variable that you haven’t defined yet or you forgot to close a String literal etc., the compiler will throw an error.
Examples of some common compiler errors (compiled from stackoverflow.com) are found below
- “…expected” - probably because of a missing semi-colon or a missing pair parentheses
- “unclosed String literal” - quite obvious, you missed a closing double quote
- “cannot find symbol” - when you try to refer to a variable that you haven’t defined yet. It would have been more helpful if this error said “variable name not found”
If you use IDE’s like Eclipse, Netbeans or IntelliJ (or even Visual Studio Code with the right plugins), the IDE will give enough visual cues, even as you’re typing the code. The following picture shows a bubble warning that shows the error.
To fix compiler errors, you just need to fix the syntax. It’s easy to fix broken syntax most of the time, especially if you use a full blown IDE.
Runtime errors
As the name of the error implies, it happens at runtime. The Java runtime spits out these errors when your program encounters a situation it didn’t expect. It’s not something that you or the compiler could have seen at the time you were writing the code (in other words, at design time). Your code may compile successfully but it may stop running when something in the enrivonment doesn’t agree with what your program wants to do. There are many examples of these things e.g.;
- You tried to reference a specific element of an array, but the element doesn’ t exist (ArrayIndexOutOfBoundsException)
- Your code performed a math operation on integers, maybe division. The divisor turned out to be zero. A divide by zero operation on integers will result in an ArithmeticException
- You tried to open a file, for some reason, the file couldn’t be opened. Maybe it was corrupted or your program didn’t have sufficient permission to open the file
- You tried to read something from the internet, maybe the network was down at the time
You get the idea. There are many things that can happen on the runtime environment that you just can’t predict. The only way to deal with this kind of error is to use Java’s ty-catch mechanism.
The try-catch looks like this
try { codes that may encounter problems } catch(Exception e) { what you will do when a problem happens }
The try-catch construction is very similar to the if-then construction. They both redirect program flow depending on a condition. In the case of try-catch, we can say the following statements;
- All of the statements inside the try block will be executed if no Exceptions will be raised by the runtime, in which case, none of the codes in the catch block(s) will be executed
- When one of the statements inside the try block encounters an error, at which point the runtime will raise an Exception, all the statements below the offending statement will no longer be executed. The program flow will jump to beginning of the catch blocks (there can be multiple catch blocks). The runtime will go through all the catch blocks and try to match the raised Exception with what’s declared on each of the catch block. When a match is found, the statements in the matching catch block’s body will be executed
We’ll have more discussions about Exceptions and the try-catch construction in the coming chapters.
Logic errors
Logic errors are the hardest to find. As its name suggest, it’s an error on your
logic. When your code is not doing what you thought it should be doing, that’s
logic error. The only way to solve this is if you walk through your code slowly and see what’s happening. Many programmers use
System.out.println in strategic places in their codes to confirm whether certain things are happening or if their expected program flow is being followed. You can use your IDE’s debugging capabilities to inspect your code. The popular IDEs will let you put breakpoints in your code, these breakpoints will let you run your program in debug mode and then halt execution when it reaches the breakpoint. It lets you pause and continue the execution of your program at strategic points. It’s a good idea to invest some time to discover the debugging capabilities of your IDE
Getting input
Glossary
Exercises
End of Part 1
I hope you were able to get something from this really quick introduction to the Java language. In Part 2, we’ll look at the following;
- Object Oriented concepts
- Types, classes and constructors
- Interfaces and abstract classes
- Some of the most common Java classes e.g. String, Data, Calendar, Math
This tutorial is lifted from the book “Java Lessons”. If you want to support the book, you might want to consider buying it at LeanPub. You’ll get the nicely formatted DRM-Free PDF, Mobi and EPub version of the book.
Revision history | http://tedhagos.com/posts/java/ | CC-MAIN-2020-29 | refinedweb | 6,647 | 70.94 |
uuid_unparse - output UUID variable in string format
Synopsis
Description
Author
Availability
#include <uuid/uuid.h>
void uuid_unparse(uuid_t uu, char *out);
The uuid_unparse function converts the supplied UUID uu from the internal binary format into a 36-byte string (plus tailing \0) of the form 1b4e28ba-2fa1-11d2-883f-b9a76 and stores this value in the character string pointed to by out.
OSF DCE 1.1
uuid_unparse was written by Theodore Y. Tso for the ext2 filesystem utilties.
uuid_unparse is part of libuuid from the e2fsprogs package and is available from.
libuuid(3), uuid_clear(3), uuid_generate(3), uuid_parse(3), uuid_time(3) | http://www.squarebox.co.uk/cgi-squarebox/manServer/uuid_unparse.3 | crawl-003 | refinedweb | 101 | 58.89 |
Details
- Type:
Bug
- Status: Closed
- Priority:
Major
- Resolution: Fixed
- Affects Version/s: 1.6-rc-1
- Fix Version/s: 2.5.0-alpha-1
-
- Labels:None
- Environment:Groovy Version: 1.6-RC-1 JVM: 1.6.0_11. WinXP
Description
Running the classes shown below results in:
groovy -cp ..\main\groovy ..\main\groovy\MainInvokeSub.groovy
Caught: groovy.lang.GroovyRuntimeException: This script or class could not be run.
It should either:
- have a main method,
- be a JUnit test, TestNG test or extend GroovyTestCase,
- or implement the Runnable interface.
However, if the 'extends MainInvokeBase' is removed or if the second class is commented out, it does run.
The only "spec" I could find about the expected behavior is in the GINA book.
file: MainInvokeBase.groovy
class MainInvokeBase {
}
file: MainInvokeSub.groovy
class MainInvokeSub extends MainInvokeBase{
static main(args)
}
def class SecondClass{
}
Activity
- All
- Work Log
- History
- Activity
- Transitions
No, that did not help:
file: MainInvokeSub.groovy
def class SecondClass{
}
class MainInvokeSub extends MainInvokeBase{
static main(args)
}
I looked into it a bit and I know what is causing it but I have no idea how to fix it.
The reason re-ordering of the classes in the source file is not having any effect is that ACG sorts the classes that it generates (needSortedInput() for classgen returns true) and the sorting is by the length of the hierarchy of the class (its distance from java.lang.Object).
So, when MainInvokeSub does not extend MainInvokeBase, length of type hierarchy of MainInvokeSub and SecondClass is same and you get back MainInvokeSub as the class to run from the source file, if it is present first in the source file.
But when MainInvokeSub extends MainInvokeBase, its type hierarchy is longer than SecondClass's and after sorting in ACG SecondClass comes ahead in order and becomes the class to run (by being the first class to be pushed from ACG to GroovyClassLoader$ClassCollector), and running it fails because it does not have any main method, etc.
Any suggestion on what I can explore to fix it?
A little clarification - to avoid one potential round-trip of comments
I did not mean that classnodes are sorted by ACG itself. I meant that they are sorted in classgen phase because ACG.needSortedInput() returns true.
The example works for me with current master, so I'm resolving this.
and switching the order of the classes in MainInvokeSub does not help? | https://issues.apache.org/jira/browse/GROOVY-3233 | CC-MAIN-2017-43 | refinedweb | 400 | 54.63 |
#include <openssl/bio.h>
int BIO_read(BIO *b, void *buf, int len); int BIO_gets(BIO *b,char *buf, int size); int BIO_write(BIO *b, const void *buf, int len); int BIO_puts(BIO *b,const char *buf);
BIO_gets() performs the BIOs ``gets'' operation and places the data in buf. Usually this operation will attempt to read a line of data from the BIO of maximum length len. There are exceptions to this however, for example BIO_gets() on a digest BIO will calculate and return the digest and other BIOs may not support BIO_gets() at all.
BIO_write() attempts to write len bytes from buf to BIO b.
BIO_puts() attempts to write a null terminated string buf to BIO b.
TBA | http://linux.jgfs.net/man/man3/BIO_puts.html | CC-MAIN-2017-17 | refinedweb | 118 | 66.07 |
These might help you..
Please post back if you have anymore problems or questions.
the drive types ...
are irrelevant. What is important in your case are what application(s) you're using to access the database, and the versions of MS SQL Server you're using. What version of SQL Server is on your older ML350, and by the way, what generation is your older M350? G3? And will you be moving to SQL Server 2005 on your G5?
The high level process in your case, will likely be:
a) On the G5 server, you'll configure the drive arrays the way you wish, and typically one might use RAID 1 (or 1+0) for O/S, application binaries, and database LOG volumes, and RAID 5 for the database and other dynamic data, for performance reasons.
b) on the G5, use smartstart and install and configure O/S and join to your Active Directory as applicable
c) install MS SQL Server (2005?) and configure
d) use MS SQL Server migration tools to migrate your database from the old ML350, here's a potentially useful article:
e) after complete testing, re-migrate the data and change the connection strings for your app(s) to point to the migrated database on the G5 server
Hope this is helpful
Hard to beat Churdoo answer
import and export of databases on SQL isn't all that problematic. SQL tools are pretty good in doing this. The big problem is the frontend application being used to access the database and present the data to a user in usable form. Often the front end application path to the data is specifically set. Maintaining good paths to the data is the gotcha as churdoo pointed out.
Database Server Migration
We have an old HP ML350, that has 4 SCSI drives configured in RAID 5, and it contains our database. My issue is, we have a new HP ML350 G5 that doesn't support SCSI, it only supports SAS and SATA. Is it possible to transfer the database on those new SAS or SATA drives and configure them in RAID 5, without any loosing the data.
By the way we are using Windows 2003 and an MS SQL for our database
This conversation is currently closed to new comments. | https://www.techrepublic.com/forums/discussions/database-server-migration/ | CC-MAIN-2019-18 | refinedweb | 381 | 66.37 |
"Let every nation
know, whether it wishes us well or ill, that we shall pay any price, bear any
burden, meet any hardship, support any friend, oppose any foe to assure the
survival and the success of liberty." John F. Kennedy.
Is it just me?
For the life of me, I can only remember two other quotes uttered from ANY
Democrat which sticks in my mind for posterity since President Kennedy made
that historic statement. These two quotes, which symbolize the current Democratic
Party more closely than I believe even THEY realize, came from the mouths of
still two of the most powerful Democrats in the party today.
Who among you will ever forget that “pearl of truth” from finger pointing
President Bill Clinton, “I didn’t have sexual relations with that woman,
Monica Lewinsky.” But, as we all came to find out, with undeniable
certainty, he DID. For all of his so called “gifted oratory”, and the THOUSANDS
of speeches he made over his eight years in office, can you remember even ONE
quote from ANY of them? I can’t, and I tried really hard. I guess that’s why he
is trying so hard to “find” a legacy for his time in office, other than the
existing one of debauchery, incompetence, and political corruption. But he sure
was popular and well liked by everyone...including the terrorists who acted and
grew with impunity during his time in office.
And this rose, plucked from the thorny bush of clarity, from our illustrious
2004 Democratic candidate for President, John Kerry, “I actually did vote
for the $87 billion dollars, before I voted against it.” Sounds like
somebody I would have wanted to vote for. That stubborn ole George Bush, he
just kept saying the same thing over and over again. What’s the fun in that?
The most amazing thing about these two “quotes for posterity” is how closely
these two “gems” STILL reflect the current views of the 2008 Democratic Party.
In Clinton’s
case, the excuse we all heard almost continuously from the “damage control”
Democratic talking heads every night for months during the impeachment trial
was, “It’s only sex, and everybody lies about that.” Yeah, so do the 14 year
old pregnant girls, who sneak off to the abortion clinics. And the kids all
over the country having oral sex parties now, because after all, they were told
over and over for months by the Democrats that oral sex “isn’t REALLY sex”.
OOPS, since it isn’t really sex, they don’t have to lie. But, it has have been
ingrained, over and over, by virtually every “wacko sex fetish” group, all of
whom ACTIVELY and WHOLEHEARTEDLY support the Democratic Party, into the heads
of every CHILD that ANY kind of sex is OK.
Gay, Lesbian, Group, Man-Boy (even the ACLU is supporting that one, by
representing the North American Man-Boy Love Association, NAMBLA in court, but
SHAME on those nasty Boy Scouts teaching about honesty, integrity, patriotism,
and wanting to keep gay troop leaders from sharing the tents of their scouts),
Animal, and Polygamy. You think I’m kidding? Just wait, as soon as they get gay
marriages passed, their next words will be something along the lines of, “But I
love BOTH Tim and Bob, shouldn’t WE have the same rights as just Tim and I, or
Bob and I can have?” Or, “Why CAN’T I marry my German Shepard?” MARK MY WORDS!
According to the Constitution, since you can’t favor one aberrant activity more
than another, so once you open the door…
Compound this with the predominate attitude of the Democratic Party, and it’s
myriad of feminist’s groups (Rush Limbaugh lumps them all together and just calls
them “feminazis”), AND now the foremost TEACHERS organization, the National
Education Association or NEA, that if our children accidentally DO get pregnant
(heaven forbid, because they have their choice of 47 different types of
condoms, supplied right in the school, available to avoid just that thing), the
child can just slip down to the corner abortion clinic, have her insides
vacuumed out, preferably WITHOUT their parent’s knowledge or consent, and
VOILA, no more problem. Why not? We have only done it over 35 MILLION TIMES
since Roe v. Wade was adopted. What’re a few million more lives snuffed out
matter, anyway? Abortions have killed more Americans than ALL of our wars
combined, but where is the Democratic outrage about THAT? Isn’t it ironic to YOU
that the “educators” (pun INTENDED) are some of the strongest supporters of
child genocide? Who would they TEACH? No wonder home schooling is increasing by
leaps and bounds!
The John F. (for “FLIPPER”) Kerry statement absolutely boggles the minds of
most reasonably intelligent people! What is particularly ironic, and
hysterically funny to me, is that he made this statement basically the SAME DAY
the first Bush ads came out during the 2004 election, claiming John Kerry
“Flip-Flops” on virtually every major issue facing America at this time. In
fact, Kerry’s OWN statement so perfectly illustrated this point to the American
public, that the Republicans revised their newly released ads, within ONE day,
to incorporate Kerry’s own IMMORTAL words into the ads. I searched for several
days after the Kerry statement for reports that Karl Rove had to be
hospitalized for a “split gut”, sustained after falling from his chair
laughing. In fact, THIS election cycle is filled with ads from everyone,
accusing everyone ELSE of “flip-flopping”. John Kerry created a whole NEW
INDUSTRY! New writers, new ads, new researchers, and a new “front” on which to
be fought by the candidates in their never-ending game of GOTCHA!
I make light, and jest, about these quotes.
But I am also saddened by the
fact that the entire Democratic Party with a few notable exceptions, such as
the retired out of frustration Senator Zell Miller from Georgia, and the now
Independent Senator Joe Lieberman (the Democrat VP candidate in 2000) who was
driven from the Democrat Party for which he nobly served for decades simply for
having the “audacity” to express his opinion favoring the Global War on Terror
seems to have morphed from a party of integrity to a party of empty rhetoric. The
Party of Roosevelt, Truman, and the Kennedys (John and Robert, both of whom are
probably turning in their graves when they see the mockery “Human Scotch
Bottle” Ted, and hypocrite “Enviro-wacko” (but I won’t give up MY private
plane) Joe has made of their name) has turned into an amalgamation of loosely
aligned wacko groups - feminists, environmentalists,
abortionists, educators, elite media, and most unions, all of which could care
less about any issue other than their own.
From the environmentalists, we get the millions of pages of regulations, which
virtually FORCE our corporations to outsource, just to stay in business. Ask
Governor “ARNOLD” why businesses are leaving California in droves.
From the feminists, we get all of those wonderful “sex sensitivity” training
classes that tell us men that we can have our butts hauled into court if we
tell our secretary (sorry, administrative director) her hair looks nice today.
From the abortionists, we get, well, we get dead babies. An entire generation
LOST!
From our educators, we get an entire generation who can’t add or subtract
without a calculator (don’t even THINK about multiplying or dividing), or speak
(let alone write) intelligible English, and who don’t know the three branches
of Government. Jay Leno proves how ignorant our youth has become at least
monthly with his “man on the street” interviews – he does them monthly, but he
could do them DAILY because there are that many “stupid kids” out there. But
they all FEEL good. What is even MORE ironic is that most young people Jay
interviews are COLLEGE STUDENTS! What the hell are they LEARNING? Learning how
to be Democrats I guess. In one recent interview by Jay, two college students
identified Speaker of the House Nancy Pelosi as Judge Judy! I REST MY
CASE!!!!! And these idiots are voting? God help us all.
From the elite media, I don’t want to go there, since this is a commentary, not
a book. But anyone can read Bernard Goldberg’s two books (Bias, and Arrogance)
to get all of the examples of complete liberal bias you would need. If they
aren’t enough, just go to NBC, ABC, CBS, CNN, NPR, MSNBC, and “Air America” (if
you can find it) practically any hour, any day. They ALL accuse Fox News of
being a shill for the “right”, because anyone to the right of Hillary Clinton
on ANYTHING is automatically part of the “vast right wing conspiracy”. By the
way, Fox News ALSO has MORE Democrats on their programs than Republicans, just
like the rest of them. The difference is, all are treated fairly, so the left
assumes that since Republicans are getting fair treatment by Fox News that means
they are “right wing”. Funny thing is that several of Fox News’ major players
have attended or held Democrat fundraisers, even for Hillary!
And finally, from the unions, we get a plethora of regulations on businesses
and local and state governments, all geared to make their “unionized” products
and services too expensive to compete on a level playing field. That includes
AFSCME (American Federation of State, County and Municipal Employees), who make
the cost of government so expensive that many local governments are now
outsourcing OUR GOVERNMENT business (such as call centers, unemployment benefit
administration, food stamp programs, and others) to places like India because
it is too expensive to do it here with our “union” labor, without significantly
raising local taxes on citizens already burdened with supporting and educating
and doctoring the millions of illegals who are depressing AMERICAN’S wages in
many industries.
And NOW, with the Reid-Pelosi-Murtha “retreat with dishonor” wing of the party
in charge, who knows what FURTHER idiocy will spew from their pie holes. Their
“peace plan for Iraq”
is nothing more than “run away as fast as you can”, and cannot even summon
enough votes to pass without BRIBING some of their members with PORK projects
added to a MILITARY SUPPLEMENTAL! Do the “dumocrats” REALLY think America
is as dumb as THEY are? The “brains” of the Democratic leadership has atrophied
to the point of senility as the “wackos” of the party consolidate their power.
If they win in 2008, grab your wallets and your white flags!
Is THIS the picture of America
you want your children to have?
Yep, the Democrat Party sure has changed. It has changed from a party of
heroes, to a party that slams and degrades heroes (like every soldier we have
in Iraq and Afghanistan).
Maybe, that’s why “Liberals” hate to be called liberals, and “Conservatives”
wear THEIR label gladly, proudly, and honorably, like I do.
There is a long standing joke out there. It goes something like this…
What do Democrats become when they grow up? REPUBLICANS!
IT IS TIME TO GROW UP AMERICA!
YES!
Well, maybe stupid is too harsh. IGNORANT is probably
better.
It AMAZES me at the continued stupidity (or maybe just
IGNORANCE) of the current “Dumocrats” in the Congress and Senate regarding
almost EVERYTHING important to our nation. Let’s look at just two examples.
They BITTERLY complain about the National Debt (currently at
around NINE TRILLION or about $30,000 per PERSON!), but yet they CONTINUE to
make STUPID decisions with respect to the economy!
EVERY TIME the federal income tax rates have been CUT
(Kennedy, Reagan, and Bush in the “modern era”), REVENUES have INCREASED! Even
the CBO (the Congressional Budge Office) confirms that revenues are at RECORD
levels, and the fatalistic estimates of the deficit have been reduced every
quarter by the strength and performance of our thriving economy, IN SPITE of
the rampant spending that STILL plagues Congress, not that the Democrats would
admit that!
But yet they have NO PROBLEM adding BILLIONS of dollars to
the debt in stupid “feel good” programs that do nothing to “help” the people
targeted to BE helped and they constantly add BILLIONS more than President Bush
wants, forcing him to veto these obscene bills. According to the Dumocrats, we
still have a “War on Poverty”, and things have only gotten worse! But we have
spent almost TWO TRILLION DOLLARS on THAT war! If we are STILL in THAT war
(after 40 YEARS!), maybe it is time to “surrender” and consider some “new
strategies” there too, instead of blindly continuing funding for THOUSANDS of
worthless, redundant programs that support even more thousands of “social
engineers” but do NOTHING to solve the PROBLEM!
GENERALLY, Democrats think that “charity” begins with the
GOVERNMENT. Conservatives (generally Republicans) believe that charity begins
at home. Republican controlled states have the highest per capita charitable
contribution rates in the nation. MISSISSIPPI,
one of the “poorest” states has the HIGHEST rate of giving than ANY state! In
fact, 27 out of the top 30 most charitable states (including ALL of the top 25)
were carried by President Bush. Contrast that to the Democrats, 17 of the top
20 LEAST charitable states (including all 7 of the least generous) voted for
John Kerry.
But EVERY TIME there is a “disaster”, ANYWHERE in the WORLD,
ALL Americans, regardless of the politics, shame all other countries in the
world with our generosity.
So why not ELIMINATE all the “War on Poverty” programs
funded by the Government?
We would save BILLIONS of WASTED tax dollars (thereby
eliminating budget deficits and the need for tax increases). Those that are
TRULY NEEDY would be given all the help they need through PRIVATE donations
(including all the social workers who will need to find another line of work,
maybe FOR the charities?). Conservative Americans will gladly contribute to
these causes as they do now. Liberal Americans (Democrats) typically donate
VERY LITTLE to charity as you can see by the statistics above, because they
feel TAXES have taken care of their “charity”. But the Government has been
proven in study after study to waste between 30-40% of EVERY dollar collected!
If any CHARITY performed that badly, NO ONE would contribute to it! Charities
(the GOOD ones anyway) have “administrative costs” of less than 10%, and many
ABSORB the costs and allow 100% of the donations to go to the “cause”, not the
administrators.
Now let’s quickly look at TAXES.
Dumocrats have never seen a tax INCREASE they didn’t like!
They “HIDE” these taxes in many ways, calling them licensing
fees, etc. To them, NOTHING is sacred and exempt from taxes, not even DEATH! To
THEM, they run the country like a wife who thinks that as long as she has
CHECKS in her checkbook, she has the money to pay for them. THAT is why we are
burdening our children with massive debt. We have SPENT the supposedly “Social
Security” surplus (to date, to the tune of about 2.9 TRILLION), replacing it
with IOU’s, payable with INTEREST! Who is going to PAY those IOUs? Our KIDS!
Right now, almost 50% of all American households pay NO
federal taxes! My source is the latest tax data released by the IRS!
The top 1% pays 36.89%! Over a THIRD! Does THAT seem FAIR to
YOU?
The top 25% pay 84.6% of the taxes burden! Does THAT seem
FAIR to YOU?
The top 50% pay 96.7% of all federal taxes! Does THAT seem
FAIR to YOU?
The BOTTOM 50% pays LESS than 4%!
How can 4 CENTS on a dollar for close to HALF the country be
considered a “FAIR share” when OTHERS are being asked to pay 40, 50 or 60
cents?
And these numbers are AFTER the TERRIBLE tax cuts for the
RICH President Bush passed. It has been proven that the “rich” are paying an
even BIGGER percentage of their income than they were BEFORE the tax cut for
THEM! Some CUT!!!
The DUMOCRATS answer?
KILL Bush’s tax cuts and ADD almost TWO TRILLION in NEW
TAXES!
The most widely discussed version of the Democratic tax plan
would result (after killing the existing cuts) in $2.9-$3.1 TRILLION in new
taxes, increasing the tax BURDEN on their “cherished middle class” by about
$3000 per YEAR! To the Dumocrats, ANYONE (with a family of 4) making over
$90,000 per year is RICH! Try saying THAT with a straight face to anyone who
lives in the DC area as I do with NO KIDS in the house (all grown and gone).
That means about $900-$1200 year of that $3000 tax increase
is going to be WASTED, according to current statistics!
Which would YOU rather have? A new plasma TV for your family
to enjoy, or throwing that money into the Government TRASH CAN to be wasted by
the idiots in Congress?
Give ME the TV!
Think about THAT as you Dumocrats blindly vote for Hillary
or Obama, or the Dumocrat Congressional and Senate candidates. If you want to
see the economy TRULY as lousy as the Dems say it is, just elect THEM, and you
will get your wish. Hopefully YOUR job won’t be one of the MILLIONS lost
because of your decision.
Nuff said.
It seems that with all of the
talk about homeland security, the biggest hole is STILL our borders with BOTH Mexico and Canada. At this point, I’m not sure
which country’s policy I fear most.
Let’s start with Canada. We all
know where and how the 9/11 hijackers got into this country, through Canada. If you
think WE have an open door policy, you should see THEIRS. Canada’s visa
and entry program is so lax, that virtually anyone can walk right through. This
has made it ideal for terrorists and most Asian illegals (primarily from China) to slip into this country from border
cities such as Vancouver, which hosts one of the
largest Chinese populations outside of China itself. So, from our friends
to the North, we get our terrorists, and Chinese illegals (most of who are
working for the Triads to pay off their “passage” fees, which can be as high as
$30,000).
Then we have our “good
buddies” to the South. While a small percentage of Hispanic illegals are from
countries “other than Mexico” (they lump all other South Americans, Europeans,
Asians, Africans, and Middle Easterners into a group they call “OTMs” or “Other
Than Mexican”) our biggest problem is clearly Mexico.
Why?
Because we previously
accepted Vicente Fox’s pledge that he was going to crack down, and stop the
flow. Because we continue to accept the new President Calderon’s pledge to do
the same thing. This is the same hollow promise that every Mexican leader has
made for years with the same results, more illegals. If we instituted the SAME
border practices that Mexico
does at THEIR southern border with Guatemala (including shooting
illegals crossing THEIR border, or prison under VERY NASTY conditions FAR WORSE
than “GITMO”), we would be pilloried by the world, every human rights
organization and the left wing press. Mexico, however, gets a pass from
all of them?
Because illegals send
BILLIONS of dollars BACK to Mexico
to help those left behind. It is public knowledge that Mexico’s four leading export products to the US are
oil, cocaine, marijuana, and illegals. THEY know it, and WE know it. Landowners
in the Border States
have had to resort to protecting their property with guns, and our Border
Control agents are in many cases out gunned by either the coyotes (illegal
immigrant smugglers) or drug runners. Plus there are the environmentalist
wackos, who are complaining the desert is being destroyed by the illegals
dumping their trash, and burning “endangered” weeds to keep warm during their
journey.
Because ALL of our elected
officials practically wet themselves when talk about FINALLY enforcing EXISTING
Immigration Laws surfaces, lest we offend the ever increasingly important
Hispanic vote. And why is the Hispanic voting bloc becoming more important? Because
of the illegals! Circular reasoning anyone?
Originally, the Bush plan was
to permit “guest workers” to come back and forth without hassle for three years
to fill jobs we are too proud to do any longer, AND take a “Government savings
account” (basically made up of what they would have been paying in Social
Security taxes if they were legal) back to Mexico at the end of the three
years. President Bush was counting on the hope that the amounts accumulated in
their accounts would be large enough to dissuade them from coming back, by
giving them a “grub stake” to start their own businesses there. No amnesty and
they must return to Mexico
at the end of the 3 years, with possibly ONE three year extension. FAT CHANCE!
But at least it was a start in the right direction, because NOTHING we are
currently doing is working. We do have to give President Bush credit here for
“thinking out of the box”.
The only real benefit that I
can see from the Bush plan is that at least we will know who is coming in. We
get them “in the system”, so we can do criminal background checks, and we have
a chance to exert a little more pressure on Mexico. If he balks, we do a mass
pick up, send them home to Mexico,
and we keep their “savings accounts”.
But that “sensible” plan (if
you can call ANYTHING other than FULL ENFORCEMENT of the BORDER and EXISTING
immigration laws sensible) MORPHED into the great big pile of crap that became
the Senate Immigration Bill, which at least the House refused to acknowledge.
It was so far apart from the House version that they would not even conference
about it. Justifiably so! The Senate version gave ILLEGAL IMMIGRANTS rights
that even US BORN CITIZENS do not enjoy, such as only having to pay taxes for 3
out of the 5 years they have been here ILLEGALLY, as if you could REALLY figure
out what that amount would even be! I’m sure all reading this (except the
ILLEGAL IMMIGRANTS in the audience laughing their tails off!) would like the
chance to only have to pay 3 years of taxes out of the last five, and I’ve been
here LEGALLY my whole life! Born in the SAME hospital that John Kerry was! What
a terrible thought!
That is just ONE of the MANY ridiculous provisions that got put in the Senate
version. But since Ted Kennedy and John McCain were the main sponsors/authors
(the human scotch bottle, and a publicity seeking nut, both IDIOTS!) of the
bill, who could expect anything better? What kind of asinine bill is that? If
we were going to go down that path, I would rather see a flat “Illegal
Immigrant” FINE (that is what you DO to LAWBREAKERS other than jail, you FINE
THEM!) of $15,000 PER PERSON (children included!) which only represents $3,000
per year (assuming the current 5 year cutoff would be maintained). But that
would make too much sense! Our elected representatives in the Senate are either
totally IGNORANT about the OVERWHELMING “will of the people” in this matter, or
are simply overwhelmingly ignorant. Me personally? I choose the latter.
What We Should REALLY Do (but don’t have the guts to)
First, we make a big
announcement. ALL illegals have 90 days to register for the “Guest Worker
Program”.
Those who can prove they have
a job can stay, provided that they have not committed any crimes here (many
areas in the US
routinely release illegal criminals right back into society instead of turning
them over to Immigration for deportation), but their “3 year clock” starts the
day they register. For the criminals, they get deported IMMEDIATELY (but who
are we kidding, the criminals aren’t going to register anyway). We contract out
the work to VISA or American Express, who have NO PROBLEM tracking us down
anywhere in the WORLD, rather than create a new government (by definition,
worthless) run bureaucracy at TWICE the cost, and HALF the efficiency.
That is what government
“unions” have brought us who STRONGLY lobby for the Democrats’ PRIME
DIRECTIVE-HIGHER TAXES and MORE BUREAUCRACY! If you think Republicans spend
money they do not have like drunken sailors, the Democrats do it like drunken
sailors on STEROIDS!
Second, we make a BIGGER
announcement that from this day forward, all illegals identified who have NOT
registered, once found, WILL BE DEPORTED OR WORSE, after being fingerprinted,
and iris scanned for posterity. If we make our allies coming into the US submit
to this now, we can certainly demand it from the illegals. I would also throw
in a DNA sample for good measure! The penalties could be as follows.
The first offense is simple
deportation. NOT RELEASE, DEPORTATION!
The second offense is also deportation, AFTER serving 60 days of “community
service” like cleaning up the desert they trashed, or building new border
fences, or if “inland”, community restoration projects, building low cost
housing, etc. The second deportation should also mean that they can NEVER
become US citizens, under ANY circumstances.
The third offense is 6 months incarceration in a “refugee camp” (wearing pink
jumpsuits like the Maricopa County, AZ Sheriff makes his detainees wear), AND 6
months “community service”, AND deportation. That is when we can stop being
NICE. Even baseball has the “three strikes” rule. There are MILLIONS of acres
of Federal land in Arizona, New
Mexico, Nevada, and Utah. Putting the
offenders in tents should be not only more cost efficient than “hard structures”,
but the number of them can be adjusted upward easily. If this isn’t as
comfortable for the illegals as what they have at home maybe they will STAY
The fourth offense is 2 years incarceration, AND 2 years HARD LABOR (maybe
thinning the forests of underbrush and cutting in fire trails, or reclaiming
landfills, or Super Fund/Katrina site cleanup, etc.), AND, of course the ever
popular deportation. After that, I don’t think there would be a fifth attempt.
But if there IS, does 10
years HARD LABOR in ALASKA
have any takers? If the Alaskans want their pork barrel “Bridges to Nowhere”
built, we can “kill two birds with one stone”, and MUCH more cost effectively.
Everybody wins, except the illegals who, after 5 violations, DESERVE to spend
some “not so quality time in caribou country”.
This plan is non-discriminatory, and it should be the same for ALL illegals,
REGARDLESS of nationality (even European and Canadian!), so we can’t be accused
of only “abusing” Hispanics, Asians, or Middle Easterners which comes with the
territory when you are trying to protect America.
It is interesting to note
that LEGAL Hispanic immigrants, who I and MOST Americans as well are COMPLETELY
IN FAVOR of, overwhelmingly want illegal immigration stopped ALSO. Many of them
spent over a DECADE waiting to come into the US legally, and RESENT those who
“cut to the front of the line” and get REWARDED for it! The legal immigrants
are also being “lumped in” with the illegals, and they don’t like it. I can’t
say I blame them.
Third, we make the BIGGEST
announcement of all. ALL COSTS INCURRED BY THE UNITED STATES AS A RESULT OF
ILLEGAL IMMIGRATION WILL BE REIMBURSED BY THE ILLEGALS’ COUNTRY OF ORIGIN.
A little while ago, Canyon County, Idaho Commissioner Robert Vasquez (note HE is HISPANIC!)
mailed a bill for almost $2 million dollars to the closest Mexican consulate,
located in Salt Lake City.
He says the county is due more than $1.4 million for jailing and more than
$575,000 for doctoring foreign lawbreakers over past two years. IS THAT GREAT
OR WHAT?
Congress should pass this as law IMMEDIATELY.
If a little county in IDAHO is spending a million a year for THEIR illegal
immigrants, think what Los
Angeles County
is spending? Any foreign aid to offending countries could be reduced by the
amount we incur to take care of their illegals for them. That’s fair, isn’t it?
We are probably using the money to aid their citizens here better than they are
in their home country anyway. They typically use theirs to line their OWN
pockets and not pass it along to their populace. If they don’t get aid, they
get a bill, or we can levy an “ILLEGAL IMMIGRANT SURCHARGE” instead, on all
import shipments coming from the offending country, or fail to approve IMF
grants and loans, or WHATEVER! Let’s hit ‘em in THEIR pocketbook, as they have
ours.
Or, in Mexico’s case, how about UNLIMITED
$20.00 per barrel oil? No more OIL CRISIS, and no need to tap ANWR. I bet the
“good ole” President Calderon of Mexico would LOVE that option. But
he would certainly take us seriously for the first time. I bet he would be
falling all over himself to seal up the border, from HIS side! If he spent the
amount of money it would COST him on his own people in Mexico, the standard of living THERE would rise
to the point where the Mexicans will stay in Mexico and build their OWN country
and future instead of depressing wages of skilled Americans (carpenters,
plumbers, landscapers, electricians, etc.).
The Democrats complain that
even in this time of remarkable prosperity in the US that wages are not keeping
up and only the wealthy are getting more wealthy. The REASON for that is the
flood of ILLEGALS filling both unskilled (where OUR young learn a trade) or
skilled labor positions for lower wages. They do this because at even the lower
wage it is FAR MORE than they could earn at home, and their EMPLOYERS benefit
from being able to charge the same, but because they no longer have the “income
tax” burden, make a BIGGER PROFIT at YOUR EXPENSE! And we do NOTHING because we
do not want to be considered “racist” by unfairly singling out a group that is
primarily Hispanic (or Middle Eastern TERRORISTS with Venezuelan passports
passing themselves off as Hispanic). What a crock of crap!
Cities may balk, saying, “We
don’t have the jail space, etc.” But I bet each city has a broken down
warehouse, or school no longer being used. That’s the first project, make the
illegals fix and secure THEIR space first (the “Dirty Dozen” approach, a great
educational movie for politicians). Then, give ‘em a sleeping bag or cot, a
couple of “PortaPottys”, and a box breakfast, lunch and dinner. Give them a
community radio (not TV, this isn’t SUPPOSED to be “Club Med”), and some cards,
books, and magazines donated by the citizenry. That’s it.
Then, outsource the transportation so they can get to their “projects”,
catering and security (all from bonded, Immigration Service approved
contractors), so it does not take away from normal law enforcement, and THERE
YOU GO!
Instant “community service”, for MUCH less than the current expense incurred
for doing it the way we are now (BADLY!), and the creation of a new “INDUSTRY”,
illegal immigration services with THOUSANDS of new jobs for CITIZENS (to take
care of the MILLIONS of illegals)!
For those “bleeding heart
Liberals” out there hollering the typical “cruel and unusual”, they should
remember that even these minimal conditions are probably BETTER than what the
illegals will have when they get “home”. They should also remember that this is
for SECOND offenders! We just deported them the first time, so they KNEW what
they were getting into when we caught them a second time, and the third time,
etc.
Also, I don’t think our
friend Calderon will want to go with the “Five Star Plan”, since HE will be
footing the BILL! For those “progressive” cities who refuse to turn in their
illegals, NO REIMBURSEMENT. Do I hear the faint sounds of public outcry from
the oppressed vast “non-progressive majority” over that one, calling for their
mayors to “get with the program” or we may decide to have a tax revolt?
As for Canada, since their entry policy is so lax, and
is used as a “Pass Through” into the US, we should make them foot the
bill for ALL those illegals, regardless of the original country they came from,
or “take it out in trade”. Cheap drugs anyone? Let CANADA
try to collect it back from CHINA,
and everywhere else that they allow their immigrants to pass through from on
their way to the US!
Think that Canada
might “reconsider” THEIR lax immigration policies too?
Plus, we will have made it harder for illegals to get in, thanks to our
“Community Service Border Enhancement Program”, the CSBEP (SIZZ-BEP). Ain’t
THAT catchy? Even sounds better than NAFTA.
If we don’t stop this horde of illegals flooding our country, sucking up our
public resources for health care, law enforcement, and education soon, our
country will no longer be ours, and you can blame the Democrats and a few
RINO’s (Republicans In Name Only) for the mess that we will be passing along to
our children.
I LOVE the Hispanic people and their wondrous heritage. My business partner is
Hispanic-African American. I have MANY fantastic Hispanic friends, and I have
visited Mexico
often. All I ask is that they come here according to the rules! That’s not
being racist, just being fair to all OUR citizens. | http://chaos.blogtownhall.com/default.aspx | crawl-002 | refinedweb | 5,625 | 68.4 |
A First Look at SQL Server Everywhere.
Starting this fall there's going to be a new alternative: Microsoft SQL Server Everywhere. SQL Server Everywhere provides an extremely lightweight (under 2MB disk footprint), easy-to-redistribute, free database from Microsoft with a syntax that's a subset of full SQL Server Transact-SQL. While it does have some limitations, SQL Server Everywhere is an ideal solution for the simple application that just needs to store a bit of data for a single user, and it's worth adding it to your list of potential tools for the future.
Not Really Version 1.0
You can download the first CTP build of SQL Server Everywhere right now, but don't let the version numbering confuse you: this isn't actually the first release of this product. Even though this is the first ever build of SQL Server Everywhere to be released to the wild, this is not a new product. Rather, Microsoft has taken the SQL Server Mobile codebase (which has been around for a number of years as a product for Windows Mobile) and rebuilt it for the desktop.
Or rather, they've publicly rebuilt it for the desktop. It turns out that their internal testing used desktop builds all along. So what we have here is a relatively mature database engine, and an executive decision to finally give it away as a means to give Microsoft an instant presence in the small-footprint embedded space. On the one hand this gives them a database that you can use consistently across anything from a PocketPC to (if you really wanted) a clustered Windows server; on the other, it provides an engine with at least rough-and-ready compatibility with full SQL Server. And of course, these days, it's .NET-programmable.
Understanding the Architecture
So what do you get in this little package? For starters, you get a compact database engine that supports a respectable subset of SQL Server's T-SQL language. That is, while you shouldn't expect every query you can write in the full version of SQL Server to run on SQL Server Everywhere, you should expect any query you write in SQL Server Everywhere to run fine on full SQL Server if you ever find yourself upgrading a database or migrating data from an embedded database to a server environment. But because of the product's roots in the mobile environment, you get more than that - in particular, there's a nice connectivity architecture for synchronizing embedded databases with server databases.
Whether on a mobile device or a desktop, a SQL Server Everywhere database can use HTTP, with or without ActiveSync, to replicate data with a full SQL Server database via IIS. You get full programmatic control over this connectivity, and can use it for both always-connected and occasionally-connected scenarios.
The new release also sports good integration with Microsoft's current developer toolset. This means a data provider for use with the .NET Compact Framework and support for ADO.NET on the desktop, management with SQL Server 2005's SQL Server Management Studio, and Visual Studio 2005 integration, among other things. If you already know how to use, say, SQL Server 2005 data with .NET, you should have no trouble making the transition to SQL Server Everywhere.
Let's See Some Code
After installing the SQL Server Everywhere CTP, fire up Visual Studio
2005 and create a new C# Windows Forms application. Add a reference to
System.Data.SqlServerCe.dll - this is the main SQL Server Everywhere
engine, which is necessary for your application to use SQL Server
Everywhere databases. Having done this, you can make the rest of the
code a bit simpler by adding a
using statement:
using System.Data.SqlServerCe;
The first thing you'll probably want to do is create a SQL Server
Everywhere database. Like Access databases, SQL Server Everywhere
databases are just files, with (by convention) the extension .sdf. You can
create one by using the
SqlCeEngine object:
SqlCeEngine eng = new SqlCeEngine("Data Source='zoo.sdf';"); if (!(File.Exists("zoo.sdf"))) eng.CreateDatabase();
After you've got a database, your existing ADO.NET knowledge will come
in handy. The
System.Data.SqlServerCe namespace contains
SqlCeConnection and
SqlCeCommand objects that
behave as you'd expect. For example, you can create a new table:
SqlCeConnection cnn = new SqlCeConnection("Data Source='zoo.sdf';"); cnn.Open(); SqlCeCommand cmd = cnn.CreateCommand(); string CreateTableString = @"CREATE TABLE ZooAnimals (AnimalID INTEGER IDENTITY (1,1) PRIMARY KEY, AnimalName NvarChar(50))"; cmd.CommandText = CreateTableString; cmd.ExecuteNonQuery();
Insert a row of data into the new table:
SqlCeConnection cnn = new SqlCeConnection("Data Source='zoo.sdf';"); cnn.Open(); SqlCeCommand cmd = cnn.CreateCommand(); string InsertString = @"INSERT INTO ZooAnimals (AnimalName) VALUES ('Giraffe')"; cmd.CommandText = InsertString; cmd.ExecuteNonQuery();
And get the data back out:
SqlCeConnection cnn = new SqlCeConnection("Data Source='zoo.sdf';"); cnn.Open(); SqlCeCommand cmd = cnn.CreateCommand(); string SelectString = @"SELECT * FROM ZooAnimals"; cmd.CommandText = SelectString; SqlCeDataReader dr = cmd.ExecuteReader(); while (dr.Read()) { string AnimalName = dr.GetValue(1).ToString(); MessageBox.Show(AnimalName); }
You'll also find the
SqlCeDataAdapter object in the
namespace, making
DataSet-based programming possible. The net
result is that if you've done any work with Access or SQL Server in .NET,
a few minutes work with IntelliSense or the Object Browser will get you up
and running with equivalent functionality in SQL Server Everywhere.<< | https://www.developer.com/db/article.php/3628751/A-First-Look-at-SQL-Server-Everywhere.htm | CC-MAIN-2018-26 | refinedweb | 895 | 55.44 |
Quesion and code is at the end
I hope this question belongs here and not to the TCS's stack.
I am trying to go through algorithms in Turk and Pentland's "Eigenfaces for Recognition".
On page 74 one can read (last paragraph of left column):
Let the training (...) The average face of the set is defined by [*]
Let the training (...) The average face of the set is defined by [*]
Where [*] is an equation saying that average face is equal to sum of images divided by it's count. In order to use this equantion I created python script using OpenCV and numpy.
On page 75 there is Figure 1. which should represent average face from Figure 1. (pg. 74) and this is what I am trying to achieve.
As a face set I am using all faces from Faces94.
When I calculate traditionall average (1/M*sum) the result looks like this:
which is far away from expected, mostly because of those wierd 'spots'.
However, when I calculate average like there was more faces than actually is (e.g. 1/(2*M) * sum) result looks more accurate:
I think there is some problem in converting int8<->int but I cannot prove it.
If anyone can spot any problem with the code please let me know even if it is not solution.
Question: what am I doing wrong / what to do to get better results.
Here is the code:
import numpy as np
import glob
import cv2
from cv2 import imread
dir = "../images/faces94/**/**.jpg"
files = list(glob.iglob(dir, recursive=True))
img = np.zeros(imread(files[0],0).shape)
img = img.astype('int')
for i in range(len(files)):
img += imread(files[i],0).astype('int')
img = np.divide(img,len(files)*2) # HERE you can change it to np.divide(img,len(files)) in order to see bad result
img = np.mod(img,128)
img = img.astype(np.int8)
cv2.imshow("image", img)
cv2.waitKey(0)
Thanks to @Divakar I found two problems in my code. | http://jakzaprogramowac.pl/pytanie/59715,average-face-algorithm | CC-MAIN-2017-43 | refinedweb | 338 | 77.13 |
This time around, i need some help figuring out how to make File::Find return (ie, stop searching/producing results) after an arbitrary number of hits.
Something like:
find({ wanted =>
sub {
my ($dev,$ino,$mode,$nlink,$uid,$gid);
my $depth = tr!/!!; # count slashes to get depth
return if (($dev,$ino,$mode,$nlink,$uid,$gid) = lstat($_))
+&&
(int(-M _) > $maxage) or (($depth < 3) or ($depth > 3)) ;
if ($_ =~ /threads\.html\z/s) {
push @files, $_;
}
},
no_chdir => 1 }, '.', $MAXHITS );
[download]
The story is this... i'm using this function to find all the files necessary to recreate an index file at bianca.com, and to actually create that file.
My current script (on my scratchpad) works for this quite well (i'll gladly provide a tarball of test filestructure to work with, just ask), without fail.
What i'm concerned about is that my test files/filestructure wasn't too big, but some of the 'live' directories that this may be working on could have literally thousands (tens, maybe 100) of files, in a very complicates directory tree. (i know, i know... but when we wrote the CGI that runs the BBS (in C, even.. heretics i know!) the filesystem-as-ersatz-database seemed OK) of files.
This introduces a huge time lag as the find function walks the tree. Since the files are invariably 'found' in the order of last-created (i'm not sure why, but it's so..) it's quite safe for me to say "stop finding once you've found n hits" since it's sure that those n files are the most recent n files, and are the ones i'm interested in.
Is there a way to do this? Does it involve hacking the module? i'm willing to give that a shot... but if there's a better non-wheel-reinventing solution...
And, if this *does* involve modifying the module, can/should/how do i post the changes so that others can use it?
as always, thanks!
There's probably a more graceful way of doing this, but an eval/die combo should work...
my $MAXHITS = 100;
eval { find( \&wanted => $dir ); };
die $@ if $@ && $@ ne "Limit reached\n";
{
my $hit_no = 1;
sub wanted {
die "Limit reached\n" if ++$hit_no > $MAXHITS;
printf "%03d %s\n", $hit_no, $File::Find::name;
}
}
[download]
my $MAXHITS = 100;
eval { find( \&wanted => $dir ); };
die $@ if $@ && $@ ne "Limit reached\n";
{
my $hit_no = 1;
sub wanted {
die "Limit reached\n" if ++$hit_no > $MAXHITS;
printf "%03d %s\n", $hit_no, $File::Find::name;
}
}
[download]
--k.
#! /usr/bin/perl -w
use strict;
use File::Find;
my @hits = ();
my $hit_lim = shift || 20;
find(
sub {
if( scalar @hits >= $hit_lim ) {
$File::Find::prune = 1;
return;
}
elsif( -d $_ ) {
return;
}
push @hits, $File::Find::name;
},
shift || '.'
);
$, = "\n";
print @hits, "\n";
[download]
The only problem is that you don't have much control over the order in which File::Find descends through the various directories. (Hint: it is not alphabetical).
#!/usr/bin/perl -w
use strict;
use File::Find;
# scrap codeee
find( { wanted => \&wanted,
# preprocess => \&preprocess,
}, '/' );
BEGIN { use vars qw( $maxHit $Hit); $maxHit = 10; }
BEGIN { $SIG{__DIE__} = sub {
my @d = @_;
if($d[-1] eq "dying max $maxHit") {
warn "hit the max $maxHit";
return();
} else {
warn(@_);
exit(1);
}
};
}
sub wanted {
my $file = $_;
print "$file\n";
$Hit++;
die "dying max $maxHit" if($Hit >= $maxHit)
}
## something like this
sub preprocess {
my @list = @_;
my $diff = $maxHit - $Hit;
warn "pre processing( $Hit, $maxHit, ".scalar(@list)." )";
if($Hit > $maxHit ) {
return ();
}elsif( @list > $diff ) {
warn "splicing";use Data::Dumper;
@list = splice(@list,0,$diff);
warn Dumper \@list;
}
return @list;
}
[download]
update: please note that the preprocess option is not available everywhere (best upgrade File::Find)
I also feel that there ought to exist File::Find::breakout, which would basically stop find from executing anymore (return? ;)
UPDATE:
after hastily posting this, which i still think is good idea, a couple of smart asses point out goto. Yeah well i'm not 0 for 2 so far ;)(dammit! sometimes solutions you know but don't love escape you)
crazyinsomniac++
The preprocess mention is great - because now I can propose an addition to fix what had bugged me about 914's current implementation of the min/maxdepth behaviour: the fact that the files have to be looked at, and if for no other other reason than to discard them. preprocess lets one avoid that:
sub prep {
my $depth = $File::Find::dir =~ tr[/][];
return if $depth > $max_depth;
return grep -d "$File::Find::dir/$_", @_ if $depth < $min_depth;
@_;
}
[download]
This way, in directories below the mindepth, nothing other than directories is even looked at. Also further recursing down the current branch of three directory tree is aborted immediately upon entering a directory deeper than maxdepth.
The mindepth test in wanted() is still necessary because the directories below mindepth will have to be processed; the maxdepth test there is superfluous.
Makeshifts last the longest.
Though it seems (from that list traffic you linked) that it's not typical for some duffer (read: me) to just modify a Module as storied and widespread as File::Find
Anyhow, it looks to me as though the $File::Find::prune way mentioned by grinder might be the way to go...
i'm pretty sure that the files i want will always be found first, since they're the most recent ones. Every time i've run this, the output array fills up in most-recentness order, on linux and solaris both. Clearly it's not alphabetical (as someone mentioned), and in fact i'm depending on this characteristic in another part of the script (there's a way to make it more robust, i'll do that later).
i'm not sure i totally understand your code, but i'll study it when i get home and can play.... thanks!
--
perl -pew "s/\b;([mnst])/'$1/g".
=head2 raDataFileFind($dir, [$noMax = 0])
Return array ref with relative file names from the $dir
directory.
$noMax -- The maximum number of files returned (0 means no
limit).
Return [] on errors.
=cut
sub raDataFileFind {
my ($dir, $noMax) = @_;
$noMax ||= 0;
my $no = 0;
my @aFile;
eval {
find( {
wanted => sub {
if(/\.txt(\.gz)?$/) {
die() if($noMax && ($no++ >= $noMax));
push(@aFile, $File::Find::name);
};
},
no_chdir => 1,
},
"$dir/");
};
return(\@aFile);
}
[download]
Does anyone know why the author of File::Find elected to make it the default action to chdir into the subdirectories? Is there any benefit of doing that, or is it an arbitrary choise?
/J
Dark
Milk
White
Alcoholic
Nutty
Fruity
Biscuity
Gingery
Spreadable
Drinkable
Moussed
Alternative e.g. Carob
None
Other kind
Results (774 votes),
past polls | http://www.perlmonks.org/?node_id=171367 | CC-MAIN-2015-27 | refinedweb | 1,100 | 68.4 |
Whatever asset allocation you choose, if it keeps you awake (and your planner too) at 3 a.m., it is not a good equation that you have got. Set it right soon.
When three of my clients came to see me for a portfolio review, I realised what a difficult job I had on my hands. Dilip, Devrajan and Kavya, the very convenient names of my three clients had such different but risky portfolios that my work was cut out.
Dilip had a portfolio of Rs 6 crore (market value had cost him Rs 3.6 crore about three years ago) in two properties in Mumbai. Both were funded by loans (amounting to Rs 3 crore). Both the properties were given on rent, and luckily for him the current rent was greater than the EMI (equated monthly installment). This was, of course, because the EMI was for a period of 20 years, and Dilip was sure as the rents went up, the situation will only look better.
Devrajan had come to me in 1999 and even though he was in a brokerage firm and had some ESOPs (Employee Stock Ownership Plan) in that company, his portfolio was completely in the debt market -- Reserve Bank of India [Get Quote] bonds, income funds, and bank fixed deposits. Out of a portfolio of Rs 4.5 crore, he had Rs 20 lakh National Savings Certificate, Life Insurance Corporation policies, Public Provident Fund, own Provident Fund -- all done to save tax. However, when she met me in 1999, I introduced her to equities.
I now had the enormous task of making a concept called 'asset allocation' and risk protection for these three.
Dilip, for example had no liquid cash and the only asset other than the two flats, was a small LIC [Get Quote] policy, and some cash balance in his savings account. He is a senior manager at a business process outsourcing (BPO) unit, has a Rs 45 lakh job, is 40 years old and has two grown up children.
His wife runs a boutique that makes no money. I convinced him that he needs Rs 6 crore insurance cover, and he should do a systematic investment planning (SIP) in an equity fund from the rent that he receives.
Dev, luckily, had started an SIP in 1999 in equity funds, and now was happy that he asked me to review his portfolio in 1999. A very strong believer in financial planning, he was convinced he could do it himself.
I just highlighted the risk of inflation and putting all money in one asset class. He now had about 20 per cent of his portfolio in excellent equity funds, which had also given him some sensational returns. He had also converted some of his income funds into equity funds, and was beaming and happy.
Kavya was my biggest problem -- she thought I was a magician and I had created the returns for her. She started calling me her lucky charm -- and would introduce me as a 'luck charm' to her colleagues. per cent return (over long periods of time) at a time when inflation used to be 10 per cent. Hence, a return of 59 per cent or 75 per cent is an aberration and not sustainable.
Let's say, you listened to your financial planner and had the following asset allocation in the year 2001:
Asset class
Allocation
Equities
40 per cent
Bonds
50 per cent
Cash
10 per cent
Now assume over the last three years, the equity markets had done well (it actually did) and now your portfolio allocation looks as follows:
70 per cent
24 per cent
6 per cent
What has happened in your life? You have got older (i.e. to say your goals have got five years closer) and your asset allocation has gone more in favor of a more volatile asset class. This is, theoretically risky.. you know what your investment portfolio has to achieve, doing an asset allocation is easy.
All portfolios should normally aim at three crore portfolio (and annual expenses of Rs 200,000) and a life expectancy of 15 more years, can choose a full debt portfolio (and reduce volatility and return) or decide to put 80 per cent in equities hoping to leave a sizeable chunk of his portfolio to his grandchildren.
It is a matter of choice. However, whatever asset allocation you choose, if it keeps you awake (and your planner too) at 3 a.m., it is not a good equation that you have got.
The author is a financial domain trainer. He may be reached at pv.subramanyam@moneycontrol.com | http://inhome.rediff.com/money/2006/aug/29perfin.htm | crawl-002 | refinedweb | 772 | 68.6 |
I'm using the "datetime" module and I'm trying to work out the difference between two dates in days. Here's the code that I'm using, with some other code coming before it that gets the object
sub.created_utc
import datetime
date = datetime.datetime.utcfromtimestamp(sub.created_utc);
print(sub.created_utc);
print(date);
print(datetime.datetime.now() - date);
1440736746.0
2015-08-28 04:39:06
287 days, 16:47:41.560711
287 days
287
Once you subtract the dates, you get a
datetime.timedelta object, and you can access its properties directly:
import datetime d1 = datetime.datetime.utcfromtimestamp(sub.created_utc) print(sub.created_utc) print(d1) result = datetime.datetime.utcnow() - d1 print(result.days)
Python statements don't end in
;; and
date is the name of a built-in library; so best not to use it in your code. | https://codedump.io/share/lcWXTstLgDxL/1/get-difference-in-days-between-today39s-date-and-previous-date | CC-MAIN-2018-09 | refinedweb | 140 | 53.47 |
For a lot of what we have been doing, our sensors are scalar values... That said, we are looking towards array detecteion/cameras.
I have some ideas, including something I think I saw in Ophyd, which is writing directly to a file on the daemon side for such large detectors (thereby only needing to transmit what is actually displayed in a client application over the RPC)
In [49]: RE(bp.scan([], ym, -5, 5, 25)) Transient Scan ID: 8 Time: 2020-04-08 19:22:56 Persistent Unique Scan ID: '667c5f23-c416-4ee7-9004-86c722454a00' New stream: 'primary' +-----------+------------+-------------+ | seq_num | time | ym_setpoint | +-----------+------------+-------------+ | 1 | 19:22:56.6 | -5.000 | | 2 | 19:22:56.6 | -4.583 | | 3 | 19:22:56.6 | -4.167 | | 4 | 19:22:56.6 | -3.750 | | 5 | 19:22:56.6 | -3.333 | | 6 | 19:22:56.6 | -2.917 | | 7 | 19:22:56.6 | -2.500 | | 8 | 19:22:56.6 | -2.083 | | 9 | 19:22:56.6 | -1.667 | | 10 | 19:22:56.6 | -1.250 | | 11 | 19:22:56.6 | -0.833 | | 12 | 19:22:56.6 | -0.417 | | 13 | 19:22:56.6 | 0.000 | | 14 | 19:22:56.6 | 0.417 | | 15 | 19:22:56.6 | 0.833 | | 16 | 19:22:56.6 | 1.250 | | 17 | 19:22:56.6 | 1.667 | | 18 | 19:22:56.6 | 2.083 | | 19 | 19:22:56.6 | 2.500 | | 20 | 19:22:56.6 | 2.917 | | 21 | 19:22:56.6 | 3.333 | | 22 | 19:22:56.6 | 3.750 | | 23 | 19:22:56.6 | 4.167 | | 24 | 19:22:56.6 | 4.583 | | 25 | 19:22:56.6 | 5.000 | +-----------+------------+-------------+ generator scan ['667c5f23'] (scan num: 8) Out[49]: ('667c5f23-c416-4ee7-9004-86c722454a00',)
from ophyd import Device, Component as Cpt, Signal, DeviceStatus import yaqc import threading import time class YaqMotor(Device): setpoint = Cpt(Signal, kind="hinted") readback = Cpt(Signal) busy = Cpt(Signal, kind="omitted") def __init__(self, port, *, name): self._client = yaqc.Client(port) assert 'has-position' in self._client.send('get_traits') self._busy_lock = threading.Lock() super().__init__(name=name) # force initial reading self._read_yaq() def set(self, value): with self._busy_lock: self.busy.put(1) self._client.send("set_position", value) st = DeviceStatus(self) def poll_busy(): busy = self._client.send('busy') while busy: time.sleep(.1) busy = self._client.send('busy') with self._busy_lock: self.busy.put(int(busy)) st._finished() threading.Thread(target=poll_busy).start() # update the signals self._read_yaq() return st def _read_yaq(self): v = self._client.send("get_state") self.setpoint.put(v["destination"]) self.readback.put(v["position"]) b = self._client.send('busy') with self._busy_lock: self.busy.put(int(b)) def read(self): self._read_yaq() return super().read() ym = YaqMotor(38001, name='ym')
Dear? | https://gitter.im/NSLS-II/DAMA?at=5e8ecb625b98016d6a23cb45 | CC-MAIN-2020-29 | refinedweb | 454 | 65.18 |
This is more complex to test in Sage than in Maple or Sympy, because "atomic" elements can belong to various classes. Furthermore, defining what is "atomic" isn't obvious in some cases...
You can test if a Sage object belongs to SR, then test if its
operator is
None, test if its belongs to a "basic" (to be defined...) ring of Sage of if it is one of the generators of its parent. But this does not exhausts the possibilities: in fact, you would have to define what is an "atomic element" for each possible category of your element...
A very rough sketch, catching only a few possibilities, could be:
def is_atomic(u): if u.parent() is SR: return u.operator() is None if u.parent() in (ZZ, QQ, AA, QQbar): return u in u.parent() # Should always return True if hasattr(u.parent(),"base_ring") and hasattr(u.parent(),"gens"): return u in u.parent().base_ring() or u in u.parent().gens() return False sage: is_atomic(x) True sage: is_atomic(x^2) False sage: R1.<t>=PolynomialRing(QQ) sage: is_atomic(t) True sage: is_atomic(t^2) False sage: is_atomic(R1(17)) True
OTOH, other possible definitions could be more useful ; for example, for univariate polynomials,
is_term could be more useful ; similarly, picking apart a polynomial via
list might offer other possibilities.
HTH, | https://ask.sagemath.org/answers/49208/revisions/ | CC-MAIN-2021-39 | refinedweb | 222 | 58.28 |
Hi,
I have two .txt files.
I am trying to combine each line from the first file with each line from the second file, using a nested loop:
I am using Code::Blocks on Ubuntu 64bit.I am using Code::Blocks on Ubuntu 64bit.Code:#include <iostream> #include <fstream> #include <string> #include <vector> using namespace std; int main () { string keyword = ""; vector<string>vectorOfStrings; ifstream ifs( "anchortxt.txt" ); string temp; while( getline( ifs, temp ) ) { vectorOfStrings.push_back( temp ); } vector<string>vectorOfStringsTwo; ifstream ifss( "rhwdtieronearticles.txt" ); string temps; while( getline( ifss, temps ) ) { vectorOfStringsTwo.push_back( temps ); } for (unsigned int i=0; i<=vectorOfStrings.size(); i++) { for (unsigned int j=1; j<=i; j++) { string aa = vectorOfStrings[i] + vectorOfStringsTwo[j]; cout << aa << endl; aa.clear(); } } return 0; }
When I try to build and run the program I get the following:
The two text files contain strings/lines which are around 500 characters in length and contain many different characters such as % | ' , .The two text files contain strings/lines which are around 500 characters in length and contain many different characters such as % | ' , .Segmentation fault
When I run the program on txt files that contain just around 30 chars per line, with just a-z characters in, it runs fine.
Can anyone suggest why this is occurring?
Many thanks | https://cboard.cprogramming.com/cplusplus-programming/141081-unable-join-two-strings-due-segmentation-fault.html | CC-MAIN-2017-26 | refinedweb | 213 | 65.22 |
Python StudentVue Library
Project description
StudentVue API
This repository provides a easy way to access data from StudentVue portals in Python programs.
This project recently transitioned to using the SOAP API from the app instead of the web-based one. Using the SOAP API is much faster, consistent, and more lightweight. However, the APIs are not compatible, so if you need compatibility the web-based one, run
pip install studentvue==1.3.2.
See documentation on the underlying SOAP API here.
Logging In
pip install studentvue or clone / download the repository and
python setup.py install.
from studentvue import StudentVue sv = StudentVue('username', 'password', 'domain name')
Documentation
You can read some basic docs here.
Bugs and Contributing
Different districts may be running incompatible versions of StudentVue. If you find such an instance or to make general improvements, feel free to raise a new issue and/or open a pull request.
Ports
C# - axiomaticTwist/StudentVueAPI
Project details
Release history Release notifications | RSS feed
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages. | https://pypi.org/project/studentvue/ | CC-MAIN-2020-45 | refinedweb | 183 | 55.54 |
Hello.
On 12-04-2011 10:44, Yury Polyanskiy wrote:
Dear all,
The notifier chain is currently called twice on OOPS. Patch below.
You need to provide your signoff for the patch to be applied.
Best,
Yury
The greeting and goodbye shouldn't be parts of the patch.
diff --git a/arch/mips/kernel/traps.c b/arch/mips/kernel/traps.c
index 4e00f9b..fdc6773 100644
--- a/arch/mips/kernel/traps.c
+++ b/arch/mips/kernel/traps.c
@@ -375,8 +375,6 @@ void __noreturn die(const char *str, str
unsigned long dvpret = dvpe();
#endif /* CONFIG_MIPS_MT_SMTC */
- notify_die(DIE_OOPS, str, regs, 0, regs_to_trapnr(regs), SIGSEGV);
-
WBR, Sergei | http://www.linux-mips.org/archives/linux-mips/2011-04/msg00073.html | CC-MAIN-2014-41 | refinedweb | 105 | 60.61 |
Your browser does not seem to support JavaScript. As a result, your viewing experience will be diminished, and you may not be able to execute some actions.
Please download a browser that supports JavaScript, or enable it if it's disabled (i.e. NoScript).
Let's say I have a simulation object and that its grid is already up-to-date. How can I find the locations of the 6 boundary planes? (or other grid properties, as those shown in the Options window).
So I only know how to get the grid settings when the simulation already has results. Don't know if this is what you are looking for, but I'll post it anyway
import s4l_v1.document as doc
import numpy as np
#get all the simulations
sims = list(doc.AllSimulations)
#select a simulation here
firstSim = sims[0]
#get the results
result_firstSim = firstSim.Results()
result_firstSim = result_firstSim['Overall Field']
#get the grid settings
GridData = result_firstSim[0]
GridData.Update()
GridData = GridData.Data.Grid
#get the axis
X = GridData.XAxis
Y = GridData.YAxis
Z = GridData.ZAxis
#create the matrix that is shown in the options mene
numGridLines = GridData.Dimensions
numCells = np.array(numGridLines) -1
minStep = np.array([np.min(np.diff(X)),np.min(np.diff(Y)),np.min(np.diff(Z))])*1000
maxStep = np.array([np.max(np.diff(X)),np.max(np.diff(Y)),np.max(np.diff(Z))])*1000
boundaryMin = np.array([X[0],Y[0],Z[0]])*1000
boundaryPlus = np.array([X[-1],Y[-1],Z[-1]])*1000
MainGridOptionsArray = np.array([numCells,numGridLines,minStep,maxStep,boundaryMin,boundaryPlus])
Maybe it is also possible to get this data without running the simulation.
I was indeed looking for a way to access this data before running the simulation (so that I can detect in advance that the simulation is likely to be very slow, or to fail, for this or that reason). So your solution does not yet solve my problem.
But thanks a lot for contributing: this piece of code will for sure end up being useful to someone!
one thing you could try is
import XCoreModeling as xcm
# get the simulation
sim = doc.AllSimulations[0]
# get bounding box of everything in your simulation
bounding_planes = xcm.GetBoundingBox(list(sim.AllComponents))
# returns a 2-tuple of Vec3 which give the opposite corners of the bounding box
# get the padding added by the grid settings
grid_settings = sim.GlobalGridSettings
for xyz in range(3):
grid_bounds[0][xyz] -= grid_settings.BottomPadding[xyz]
grid_bounds[1][xyz] += grid_settings.TopPadding[xyz]
This should be accessible once the simulation has been set up, but before it has been run. Hope this helps!
@CEiber That's a very good idea, thanks a lot! | https://forum.zmt.swiss/topic/42/how-to-get-the-bounding-box-of-the-computational-domain-of-a-given-simulation-from-python | CC-MAIN-2021-17 | refinedweb | 444 | 52.66 |
From Documentation
Overview
With the native namespace, an XML element in a ZUML document will be interpreted as a native tag that will be sent to the browser directly, rather than becoming a ZK component.
For example,
<n:ul xmlns: <n:li> <textbox/> </n:li> <n:li> <textbox/> </n:li> </n:ul>
will attach the following HTML tags to the browser's DOM tree:
<ul> <li> <input id="z_a3_2"/> </li> <li> <input id="z_a3_5"/> </li> </ul
where <input> is the HTML tag(s) generated by the textbox component. Unlike textbox in the example above, ZK Loader doesn't really create a component for each of ul and li.[1] Rather, they are sent to the client directly. Of course, they must be recognizable by the client. For a HTML browser, they must be the valid HTML tags.
Dynamic Update
The XML elements associated with the native namespace will be considered as tags that the client accepts, and they are sent directly to the client to display. They are not ZK components, and they don't have the counterpart (widget) at the client either. The advantage is the better performance in term of both memory and processing time.
However, the disadvantage that is you cannot access or change them (neither component nor widget) dynamically. For example, the following code snippet is incorrect, since there is no component called x.
<n:ul <button label="add" onClick="new Li().setParent(x)"/> <!-- Failed since x is not available at the server -->
If you want to change them dynamically, you could:
- Use client-side code to modify the browser's DOM tree at the client. Notice that, since ZK doesn't create the widget at the client too, you have to manipulate the DOM tree directly.
- Use the html component if you won't mix ZUL with HTML tags.
- Use the components from the XHTML component set as described in the following section.
For example, we could use jQuery to modify the DOM tree as follows:
<zk xmlns: <n:input <button label="change" w: </zk>
The rule of thumb is to use the native namespace if possible. If you need to change the content dynamically, you might consider the html component first. If still not applicable, use the XHTML component set.
Relation with Other Components
Though no component is associated with the element specified with the native namespace, you still could manipulate its parent, such as invalidate and move. For example, the following works correctly.
<window border="normal" title="Redraw"> <n:ul xmlns: <n:li>ZK is simply best</n:li> </n:ul xmlns: <button label="Redraw" onClick="self.getParent().invalidate()"/><!-- OK to invalidate a component --> </window>
As shown, it is OK to invalidate a component even if it has some native tags.
Also notice that, though the native HTML tags will be generated for the native namespace, ZK Loader actually creates a component to represent as many as these native HTML tags. Thus, if you invoke Component.getPreviousSibling() of the button above, it will return this component. However, don't access it since the real class/implementation of the component depends on the version you use and might be changed in the future.
In Pure Java
You could use the native namespace in Java too. For example, you could create a native table directly as follows.
import org.zkoss.zk.ui.Component; import org.zkoss.zk.ui.HtmlNativeComponent; import org.zkoss.zul.Datebox; public class TableCreator { public void createTable(Component parent) { HtmlNativeComponent n = new HtmlNativeComponent("table", "<tr><td>When:</td><td>", "</td></tr>"); n.setDynamicProperty("border", "1"); n.setDynamicProperty("width", "100%"); n.appendChild(new Datebox()); parent.appendChild(n); } }
As shown, the first argument of HtmlNativeComponent.HtmlNativeComponent(String, String, String) is the name of tag. The second argument specifies the content that will be generated right before the children, if any. The third specifies the content after the children, if any. In addition, the setDynamicProperty method could be used to set the attributes of the tag.
In summary, the above example is equivalent to the following ZUML document:
<table border="1" width="100%" xmlns="native" xmlns: <tr> <td>When:</td> <td><u:datebox/></td> </tr> </table>
Output Tags with Another Namespace
If the HTML tag you want to output requires a XML namespace (such as XAML), you can use the following format to specify the URI of the XML namespace you want to output:
<element xmlns="native:URI-of-another-namespace">
For example, if you want to output the XAML tags directly to the client, you can specify XAML's XML namespace as follows.
<div> <Canvas xmlns="native:"> <TextBlock>Hello World!</TextBlock> </Canvas> </div>
Then, the result DOM structure will be similar to the following[1]:
<div id="zk_uuid"> <canvas xmlns=""> <textblock>Hello World!</textblock> </canvas> </div>
Version History
Last Update : 2011/7/25 | http://books.zkoss.org/wiki/ZK_Developer's_Reference/UI_Patterns/HTML_Tags/The_native_Namespace | CC-MAIN-2016-07 | refinedweb | 799 | 55.13 |
Initialization code in your AutoCAD .NET application
It's very common to need to execute some code as your application modules are loaded, and then to clean-up as they get unloaded or as AutoCAD terminates. Managed AutoCAD applications can do this by implementing the Autodesk.AutoCAD.Runtime.IExtensionApplication interface, which require Initialize() and Terminate() methods.
During the Initialize() method, you will typically want to set system variables and perhaps call commands which execute some pre-existing initialization code for your application.
Here's some code showing how to implement this interface using VB.NET:
Imports Autodesk.AutoCAD.Runtime
Imports Autodesk.AutoCAD.ApplicationServices
Imports Autodesk.AutoCAD.EditorInput
Imports System
Public Class InitializationTest
<CommandMethod("TST")> _
Public Sub Test()
Dim ed As Editor = _
Application.DocumentManager.MdiActiveDocument.Editor
ed.WriteMessage("This is the TST command.")
End Sub
End Class
And here's the equivalent code in C#:
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.EditorInput;
using System;
public class InitializationTest
: Autodesk.AutoCAD.Runtime.IExtensionApplication
{
public void Initialize()
{
Editor ed =
Application.DocumentManager.MdiActiveDocument.Editor;
ed.WriteMessage("Initializing - do something useful.");
}
public void Terminate()
{
Console.WriteLine("Cleaning up...");
}
[CommandMethod("TST")]
public void Test()
{
Editor ed =
Application.DocumentManager.MdiActiveDocument.Editor;
ed.WriteMessage("This is the TST command.");
}
}
A few notes about this code:
.NET modules are not currently unloaded until AutoCAD terminates. While this is a popular request from developers (as it would make debugging much simpler), my understanding is that this is an issue that is inherent to the implementation of .NET - see this MSDN blog post for more information.
What this means is that by the time the Terminate() method is called, AutoCAD is already in the process of closing. This is why I've used Console.Write() rather than ed.WriteMessage(), as by this point there's no command-line to write to.
That said, you can and should use the Terminate() callback to close any open files, database connections etc.
Something else you might come across when implementing this... I've implemented a single command in this application for a couple of reasons: in my next post I'm going to segregate the command into a different class, to show how you can tweak your application architecture both to follow a more logical structure and to optimize load performance.
The second reason I added the command was to raise a subtle you might well hit while coding: you might see the initialization string sent to the command-line as the application loads, but then the command is not found when you enter "TST" at the command-line. If you experience this behaviour, you're probably hitting an issue that can come up when coding managed applications against AutoCAD 2007: there's been a change in this version so that acmgd.dll is loaded on startup, and under certain circumstances this assembly might end up getting loaded again if found on a different path, causing your commands not to work.
The issue can be tricky to identify but is one that can be resolved in a number of ways:
- Edit the Registry to disable the demand-loading "load on startup" of acmgd.dll (a bad idea, in my opinion - it's safer not to second guess what assumptions might have been made about the availability of core modules)
- Make sure AutoCAD is launched from its own working directory - commonly this issue is hit while debugging because Visual Studio doesn't automatically pick up the debugging application's working directory
- Set the "Copy Local" flag for acmgd.dll to "False". "Copy Local" tells Visual Studio whether the build process should make copies of the assemblies referenced by the project in its output folder
My preference is for the third approach, as on a number of occasions I've overwritten acmgd.dll and acdbmgd.dll with those from another AutoCAD version (inadvertently trashing my AutoCAD installation). This usually happens when testing projects across versions (projects that's I've set to output directly to AutoCAD's program folder, for convenience), and I've forgotten to change the assemblies references before building.
So I would actually set both your references to acdbmgd.dll and acmgd.dll to "Copy Local = False". You can do this either by selecting the Reference(s) via the Solution Explorer (in C#) or via the References tab in your Project Properties (in VB.NET) and then editing the reference's Properties.
Hi Kean,
First of all, I would like to thank you for having such a fantastic source of information on the AutoCAD .NET API. I found it to be the best resource to get started with AutoCAD .NET programming.
My question is the following: my app needs to create a toolbar. I want the toolbar to load on startup, so I created it at my IExtensionApplication implementation class. I can see the toolbar when AutoCAD starts up, but once the Initialize() method is executed, the toolbar hides again. So I am wandering if this is the right place to create the toolbar.
Thanks in advance :-)
Rubén D.M.
Posted by: Ruben | January 17, 2007 at 09:28 AM
Hi Rubén,
Thanks for your feedback - very nice of you.
I'd suggest posting some code reproducing the problem to the AutoCAD .NET discussion group and sending me the URL by email (otherwise, if you're an ADN member, submit the project via DevHelp Online and email me the case ID).
Regards,
Kean
Posted by: Kean | January 17, 2007 at 02:27 PM
Hello,
I create a VB.NET program that call autocad 2004
network version, and I run a lisp rutine.
few days ago I install Autocad 2007, now if I have open 2007, run a new sesion for autocad 2007, but I just want my Vb.Net program that work
with 2004 network version.
if any way to call a specific version of autocad from VB.NET.
Thank you.
Posted by: Alberto Benitez | August 08, 2007 at 04:54 PM
Hi Alberto,
Unfortunately it's not clear to me what exactly you need help with, and neither does it appear related to this post...
Please submit a more detailed description either to one of the discussion groups, or to the ADN team, if you're a member.
Regards,
Kean
Posted by: Kean | August 08, 2007 at 06:55 PM
Hi Kean,
I'm wondering what state the document (and/or application) is in when the initialize method fires. My first guess would be that it is locked/busy, and therefore any code which attempted to read from the Database would fail due to the document being locked?
Posted by: David Osborne | November 13, 2008 at 02:44 AM
I'm amazed... All the other things I ever tried, like calling a SetVars routine from the MNL file or the ACADDOC.lsp, would always fail saying there was a lock violation when I tried to read an Extension Dictionary on AutoCAD startup, or on DocumentActivated. I netload my dll from an MNL file so this initialize method executed even before the ACADDOC.lsp, but it works this way...no lock violation.
BTW, I don't think I'm going to be able to make AU 2008, but if you ever find yourself in the Denver, CO area with some time to kill, I definitely owe you a beer. Actually a person could die from alcohol poisoning if you drank all the beers I owe you in one sitting ;-)
Posted by: David Osborne | November 13, 2008 at 03:26 AM
A great question. You actually can't rely on the document being ready for you to do anything much at all - if your module is set up to load on AutoCAD initialization, there's no guarantee you even have an active document.
What I tend to do is to P/Invoke ads_queueexpr() to fire off a command with my initialization stuff:
[assembly: ExtensionApplication(typeof(MyNamespace.Application))]
namespace MyNamespace
{
class Application : IExtensionApplication
{
[DllImport("acad.exe", CharSet = CharSet.Auto, CallingConvention = CallingConvention.Cdecl)]
extern static private int ads_queueexpr(string strExpr);
public void Initialize()
{
ads_queueexpr("(command \"_INITMYAPP\")");
}
...
This seems worthy of a follow up post (one for the list).
Kean
P.S. Sounds like a great offer... haven't been to the mile-high city in many moons, but then you never know. :-)
Posted by: Kean | November 13, 2008 at 09:00 AM | http://through-the-interface.typepad.com/through_the_interface/2006/09/initialization_.html | crawl-002 | refinedweb | 1,392 | 55.84 |
Hi, i need some help with a program that calculates the numeric value of a name. The value of a name is determined by summing up the values of the letters of the name where 'a' is 1, 'b' is 2, 'c' is 3 etc., up to 'z' being 26. For example, the name "Zelle" would have the value 26+5+12+12+5=60. Write a program that calculates the numeric value of a complete name such as "John Marvin Zelle". I can get it to work for one name but for a complete name i am lost. Here is my code so far:
import string import math def main(): word=raw_input('Enter your name:') sum=0 word=string.upper(word) s=string.split(word) print s for l in word: sum=sum+ord(l)-64 print'The numeric value of your name:',sum main()
any help would be appreciated | https://www.daniweb.com/programming/software-development/threads/382082/python-program-help | CC-MAIN-2017-13 | refinedweb | 151 | 80.21 |
from math import * class vector: def __init__(self, x, y, z): self.x = float(x) self.y = float(y) self.z = float(z) def dot(self, other): return self.x*other.x + self.y*other.y + self.z*other.z def cross(self, other): return vector(self.y*other.z-self.z*other.y, self.z*other.x-self.x*other.z, \ self.x*other.y-self.y*other.x) def mod(self): return pow(self.x**2+self.y**2+self.z**2, 0.5) def __sub__(self, other): return vector(self.x-other.x, self.y-other.y, self.z-other.z) def __add__(self, other): return vector(self.x+other.x, self.y+other.y, self.z+other.z) def __str__(self, precision=2): return str(("%."+"%df"%precision)%float(self.x))+'i'+('+' if self.y>=0 else '-')+ \ str(("%."+"%df"%precision)%float(abs(self.y)))+'j'+('+' if self.z>=0 else '-')+\ str(("%."+"%df"%precision)%float(abs(self.z)))+'k' if __name__ == "__main__": print "Enter x,y,z(separeated by space) value of vector-1" A = vector(*map(float, raw_input().strip().split())) print "Enter x,y,z(separeated by space) value of vector-2" B = vector(*map(float, raw_input().strip().split())) print "A + B: " + str(A+B) print "A - B: " +str(A-B) print "A[.]B: " + str(A.dot(B)) print "A[X]B: " + str(A.cross(B)) print "Modulas of A (|A|): " + str(A.mod()) print "Modulas of B (|B|): "+ str(B.mod()) print "Angle between then in radian is %.2f"%degrees(acos(A.dot(B)/(A.mod()*B.mod())))
>>>
Enter x,y,z(separated by space) value of vector-1
2 4 -5
Enter x,y,z(separated by space) value of vector-2
-1 3 -2
A + B: 1.00i+7.00j-7.00k
A - B: 3.00i+1.00j-3.00k
A[.]B: 20.0
A[X]B: 7.00i+9.00j+10.00k
Modulas of A (|A|): 6.7082039325
Modulas of B (|B|): 3.74165738677
Angle between then in radian is 37.17
Explanation:-
Here we have used operator overloading concept to add/subtract vectors. Refer this for another example of operator overloading in Python.In order to find radian value of angle between two vector used math.acos(x) which return the arc cosine of x, in radians.
Aivivu - đại lý chuyên vé máy bay trong nước và quốc tế
vé máy bay đi Mỹ
vé máy bay đi sài gòn giá rẻ nhất
vé máy bay sài gòn hà nội khứ hồi
vé máy bay hn nha trang
vé máy bay giá rẻ đi bình định
taxi sân bay nội bài
Combo Phú Quốc | https://www.devinline.com/2016/09/vector-arithmetic-dot-and-cross-product.html | CC-MAIN-2021-25 | refinedweb | 442 | 62.75 |
October 12, 2007
Global Economy Now Slowing Down
by Henry To last Thursday (October 4, 2007) at
13,956, giving us a loss of 110 points as of Friday at the close.
As of Sunday evening on October 7th, we are 50% short in our DJIA Timing System
(subscribers can review our historical signals at the following
link). In our "Special Alert" last Thursday morning, we briefly discussed
our reasons for going 50% short in our DJIA Timing System. I will briefly recap
them here:
Continuing divergences among the major U.S. stock market indices - with
none of them confirming the new recent all-time highs in the mega and large
cap indices such as the Dow Industrials, the S&P 500, and the Russell
Top 200 Index. Moreover, from a Dow Theory standpoint, we have continued
to witness a significant amount of weakness in the Dow Transports since
the rally off the mid-August lows. Even within the S&P 500 Index, only
the larger names are outperforming. Case in point: Over the last three
months, the total return (i.e. including dividends) of the S&P 500
Index is 2.03%. However, on an equal weighted basis, the S&P 500 Index
is actually down 2.19% over the last three months.
The two major stock markets in the world with the most relative strength
in the last few months - the Shanghai Stock Exchange and the Hong Kong
Stock Exchange (the latter exemplified by the Hang Seng Index) is now losing
significant strength. In fact, the latter index completed a huge one-day
reversal in Wednesday's trading session. Moreover, aside from what I had
just discussed in this morning's commentary on the Hang Seng, the number
of new highs in Hong Kong actually topped out in late May - and has been
consistently decreasing since that time. There is no question that the
strongest stock markets in the world are now losing strength, and this
will not bode well for the U.S. stock market going forward.
The recent strength in the U.S. Dollar - plus the fact that it is still
significant oversold. Given that as much as 50% of earnings in the Dow
Jones Industrials come from foreigners, there is a good chance that there
will be a squeeze in the profits of the Dow Industrials' components over
the next couple of quarters - should the USD Index continue to rally. This
is significant, as any dollar rally against the Euro and the Yen will also
mean a lower Chinese Renminbi - as the latter is pegged to a basket of
the world's major currencies, including the USD.
Again,. Also, given that much of the strength in the
U.S. stock market has been focused on the Dow Industrials over the last six
weeks, there is a good chance that the Dow Industrials could. Given that as much as 50% of profits within
the Dow Industrials and the S&P 500 is derived from outside of the US,
we would never have gone short within. The $64
billion quest now is: Given that US economic growth is set to continue to slow
down over the next couple of quarters, will foreign earnings growth prove to
be strong enough to offset any shortfall in earnings within the US?
Let us now try to answer this question by taking a look at the latest update
of our "MarketThoughts Global Diffusion Index" (MGDI). We first featured the
MGDI in our May 30,
2005 commentary - with our last update coming in our September
9, 2007 commentary.
August 2007 (the September 2007 reading will be updated and available on the
OECD website in early November).) is now trending down - suggesting that the chances
of a U.S. recession has just gotten a little bit higher (although we are
still not looking for one at this stage)..
The deteriorating global economic growth is also being confirmed by the most
recent weakness in base metal prices - a definite leading indicator of global
economic growth given that much of the recent growth has been dependent on
industrialization and infrastructure construction in countries like China,
India, Brazil, Vietnam, United Arab Emirates - not to mention a real estate
bubble in countries like the UK, Spain, France, Australia, and the US. Following
is a daily chart showing the spot prices of selected base metals with a base
value of 100 on January 1, 2003:
As mentioned on the above chart, copper and aluminum prices have most probably
topped out in May 2006, while nickel made a significant top in May 2007 and
tin in early August 2007. The only metal of consequence (a metal that is not
shown is zinc - an essential ingredient of stainless steel - and which is down
about a third from its November 2006 all-time highs) that is still making all-time
highs is lead. Given the divergence of all other base metals, and given the
continued weakness in silver prices, chances are that:
1) The up cycle in metal prices in general have topped or is in the midst
of topping out;
2) Global economic growth will at least slowdown over the next several quarters,
as base metal prices have been a great leading indicator of the current global
economic cycle.
While the bulls would claim that the new highs in the Baltic
Dry Index is still signaling immense growth, subscribers should keep
in mind that the Baltic Dry Index is merely a coincident indicator of the
global economy at best - as it is just a representation of spot shipping
rates of dry, raw materials. That is, it is a representation of shipping
rates for dry, raw materials that is being shipped right at this instant
- raw materials that were bought as long as a few months ago, when prices
were still high. The recent decline in base metal prices suggests that the
Baltic Dry Index will also start to reverse and decline over the next several
months. Moreover, a better leading indicator of global economic growth - container
traffic within the Port of Los Angeles (the busiest port in the US) -
is expected to be stagnant on a year-over-year basis for the rest of this
year. Given that much of the container traffic within the Port of Los Angeles
is in the form of finished goods, this is a much better leading indicator
of US (and to a lesser extent, global) economic growth than the Baltic Dry
Index.. » | http://www.safehaven.com/article-8600.htm | crawl-001 | refinedweb | 1,078 | 60.28 |
18 October 2011 04:24 [Source: ICIS news]
GUANGZHOU (ICIS)--?xml:namespace>
The country recorded a GDP growth of 9.5% in the second quarter and a 9.7% pace of expansion in the first quarter.
In the first nine months of 2011,
Its industrial output expanded by 14.2% year on year in January to September 2011, with fixed asset investments recording a 24.9% growth, according to the data. Total retail sales for the period grew by 17.0% year on year, NBS said.
The third-quarter economic data were within the Chinese government’s expectations, indicating that the financial and monetary measures that have been implemented are taking effect, said Sheng Laiyun, spokesman of N | http://www.icis.com/Articles/2011/10/18/9500727/china-economy-grows-slower-in-q3-at-9.1.html | CC-MAIN-2014-42 | refinedweb | 118 | 68.97 |
Discord.py problems.
Is the file with your code called
discord.pyperhaps? If so, you need to rename it - otherwise when you say
import discord, it will import your own script instead of the
discordmodule.
Also just FYI, it's not possible to have a Python script run while Pythonista is in the background - iOS does not allow apps to run in the background for a long time. I don't know anything about writing Discord bots, but I assume that you have to keep your script running in order for the bot to work. So if you want your bot to always run, without having to start it manually first, you're probably better off running it on a regular computer instead of a mobile device.
@dgelessus Yes, I have renamed the file to my_bot.py from discord.py, I was unaware. I now have a new error:
No module named ctypes.macholib
Google is your friend: | https://forum.omz-software.com/topic/4794/discord-py-problems/3 | CC-MAIN-2020-45 | refinedweb | 158 | 73.17 |
here is waht I'm tring to do:
and coding done by meand coding done by meQuote:
A household is preparing its next month's budget. For this, they want to estimate their monthly grocery spend. They expect their next month's grocery spend to be 10% higher than the average spend over the last several months. Given their grocery spend for the last several months, the expected spend should be rounded off to 2 decimal places. For e.g. if the input is {1004.56,1200,989.50,1100,1050.36,1000.88,1104.56, 990,1089.50,1070,1310.36,900.88}, the expected output is 1174.31
Code :
import java.text.DecimalFormat; public class GroceryPlan { static double[] test1 = {1004.56,1200,989.50,1100,1050.36,1000.88,1104.56,990,1089.50,1070,1310.36,900.88}; static double[] testcase = test1; public static void main(String args[]){ GroceryPlan inst = new GroceryPlan(); double v = inst.getEstimate(testcase); System.out.println(v); } // Write your code in the function below public double getEstimate(double[] spends){ double total=0,inc=0; DecimalFormat Form = new DecimalFormat("#.##"); double count= spends.length; for(double element:spends){ total+=element; } System.out.printf("total amount : %.2f\n",total); System.out.println("Months :"+count); total/=count; inc=total*0.1; total+=inc; return Double.valueOf(Form.format(total)); }
output is looking fine but look here when code is check for quality
Attachment 1093
Please guide me how to format double values? please look at the screen shot | http://www.javaprogrammingforums.com/%20whats-wrong-my-code/14455-how-format-double-value-printingthethread.html | CC-MAIN-2014-42 | refinedweb | 251 | 51.85 |
Guys,
I have been playing around with David Edward's Kalman Pairs algorithm (), and it is really well written. However, I am completely confounded when I try to update "history" to "data.history":
def update(self): prices = np.log(history(bar_count=1, frequency='1m', field='price')) self.X.update(prices) self.Y.update(prices) self.kf.update(self.means_frame().iloc[-1])
I understand how to update from "history" to data.history, but what has me confused is that data.history takes an asset/asset list as an input/argument and history does not. When I try to use self._x or a combination of self._y and self._x, the algorithm ceases to trade, and I don't understand how it should be updated to input the necessary pair. I've also tried to use data.current, since it seems like that would logically work (since it is just updating the price from one minute ago).
Would anyone be able to point me in the right direction (take pity on me) and help me understand how to update this to make it work?
Joseph | https://www.quantopian.com/posts/help-with-deprecation-warnings | CC-MAIN-2018-13 | refinedweb | 184 | 60.41 |
Engineering Help Desk
- see also: Wikiversity:Help desk.
Procedure: Add your question to the bottom of the list, below.
- Another place to ask a question about Wikiversity is: Colloquium.
- If you are new to wiki, see: Help:Editing
Feel free to ask questions below or at the following volunteers talk page:
Questions:
Contents
- 1 How Can I Calculate the Stress of Saddle Clamp Bolts Supporting a Vertical Mast?
- 2 Where are the files I contributed six months ago?
- 3 Can I request special attention for the files I need to get started?
- 4 Is any Free Engineering actually occurring at Wikiversity?
- 5 Efficient Combuustion Needed
- 6 Where to put Polymer technology?
- 7 Relating flow rate of compressed gas to pressure
- 8 How Can I Calculate the Stress of Saddle Clamp Bolts Supporting a Vertical Mast?
- 9 Helium flow rate compared to argon
- 10 Mechanical joint problem
- 11 Pressure Drop Across a Constricted Annulus and the Venturi Effect
- 12 I NEED HELP PLEASE!!!!!!!!!!!!!!!!!!! (Bird house)
- 13 microprocessor based EPROM programmer
- 14 Manufacturing steel tubes
- 15 How to tolerance a bolt hole given the bolt size and free fit?
- 16 Grain Growth
- 17 Underwater ROV
- 18 How to calculate the temperature change of fluid inside a casing
- 19 Are Velocity (mm/s) measurements obtained using an accelerometer comparable to those obtained using a Geophone?
How Can I Calculate the Stress of Saddle Clamp Bolts Supporting a Vertical Mast?[edit]
(Question moved to the bottom of page. StuRat 15:28, 12 September 2008 (UTC))
Where are the files I contributed six months ago?[edit]
Answer: Probably still at Wikibooksb:Main_Page or lost in the link maze locally. Only a few Custodians have been appointed and it will take a while to sort out the elements of the database being moved from Wikibooks to the new dedicated name spaces at permanent URL. Please try a search either here or at Wikibooks.
Can I request special attention for the files I need to get started?[edit]
Answer: Yes. Request the files be transwiki'd here: it may take a few hours as there are only a few appointed Custodians (synonmous with administrator, sysop).
Is any Free Engineering actually occurring at Wikiversity?[edit]
I am doing some at Lunar Boom Town. If you have some time ask me how and why I am developing pieces and I can give you some pointers to places where the data,tools,techniques, are starting to pool up and become self organizinng with emergent properties with growing participation. Some of the folks at googles sci.space.* groups can helpfully assess the potential and limitations inherent in distributed virtual companies. The eductainment is still being researched and developed .... need some effective data feedback and improving mechanisms. 70.110.62.240 19:40, 26 November 2007 (UTC)
Efficient Combuustion Needed[edit]
My parents will not allow me to have natural gas pipeline plumbed into the workshop areas I borrow and rent from them so I can operate a microfoundry for aluminum parts for engineering research and commercial network game opportunities I wish to pursue. Can sombody help me learn what some better or worse options might be? Mirwin 19:55, 26 November 2007 (UTC)
- I suggest propane tanks. They are readily available for use with barbecue units. The 1900°C temp of a propane flame is more than enough to melt aluminum (which melts at around 660°C). However, aluminum fumes are toxic, so you will need a good exhaust fan and a smokestack so you release the fumes above the elevation where people might breathe them. This will also require that you locate in an area zoned for industrial usage. This type of activity would not be permitted in a residential area. Also, depending on the jurisdiction, special permits may be required, and "scrubbing" of the exhaust fumes may be expected to gain approval. The obvious fire hazard from using combustible gases will also likely bring about requirements for extra fire precautions, like sprinklers. StuRat 22:35, 26 November 2007 (UTC)
- Excellent information StuRat! Thanks. I will investigate air scrubbers and local zoning requirements. It is possible there is some lower limit on size of activity that will allow a tiny quantity of tiny parts to be cast in a microfoundry. Point about air quality is still taken seriously by me and I will investigate options although 20 years ago in local high school no special precautions were taken in much larger pours other than an excellent ventilation system in a large volume shop area. Despite that shop training I retained no idea that aluminum fumes were toxic so I wish you to know that you have assisted me greatly here. Thanks again! Mirwin 19:58, 18 December 2007 (UTC)
- You're welcome. See w:Aluminum#Health_concerns for info on aluminum toxicity. StuRat 20:12, 8 January 2008 (UTC)
Where to put Polymer technology?[edit]
- Hello Wikiversity - people! I just joint this project and I have already my first question. In Germany "Polymer Technology" is considered a part of "Mechanical engineering". But in the english speaking part of the world it is considered a part of "Material Science". At which Portal should I start working. There is already a speciality "Polymers" in "Materials science and engineering". But that is more about the chemistry of polymers. But the "engineering part of polymers" is another thing than "engineering with steel" as there are quite a few special topics to consider. This won't be a problem for the next few weeks, as there is enough to learn about wikiversity itself and there definitely is a lot of material I'll contribute to the chemical side of polymer technology. But still I would like to have some opinions on that one. Yours Akinom 13:25, 8 January 2008 (UTC)
- UPs. I think I may have found the solution. The german "Kunststofftechnik" isn't "Polymer Technology" but "Polymer engineering". Sorry for that one. But there comes the next question. Is "Polymer engineering" considered a department in the "School of Engineering" or is a subdivision of "Mechanical engineering"? Akinom 13:25, 8 January 2008 (UTC)
- I have an engineering degree from the US and would break it down like this:
- Mechanical engineering: Engineering subjects which do not depend on the material.
- Material science: Mechanical properties of materials.
- Chemistry: Chemistry of materials.
- So, polymer engineering would fall under materials science, in my opinion. I'd add links from the adjacent fields of chemistry and mechanical engineering, however, so everyone can find your material :-). StuRat 20:20, 8 January 2008 (UTC)
"The future is in plastics" they used to say...but those were the businessmen. Invented by Chemists, created by Chemical Engineers and mass Manufactured by Mechanical and Industrial engineers, I would indeed go so far as to create a branch of engineering called Polymer Engineering and to add it to the template. The information you have may be most suitable to Chemistry (science behind it) or Chemical Engineering (how to make it), Industrial Engineering (plastics in a larger scope), Mechanical Engineering (ways to use it), and/or Materials Science (how it behaves as a material). A good curriculum for a Polymers Engineer would include all of these courses. -71.159.31.220 04:01, 19 February 2008 (UTC)
Relating flow rate of compressed gas to pressure[edit]
Hi, folks. How much information is needed to find (even to within about 20%) the flow rate of a tank of gas compressed at a given pressure? Specifically, given a tank of 0.4m^3 helium compressed to 16500 kPa, is it possible to work out (on paper) what pressure to regulate it down to in order to achieve an initial flow rate of 15 lpm? Would I need to know the area of the narrowest part of the outlet? Thank you, Lsterling 06:56, 14 July 2008 (UTC)
- Yes, you would need to know the cross sectional area of the narrowest restriction, but also the shape of that opening. A circular opening should allow for faster flow than a narrow slit of the same cross sectional area, for example. You would also need to know the type of fluid (helium, in this case) and pressure in the tank (16500 kPa, in this case) and the pressure in the target container. Other factors, like the fluid temperature, and the smoothness, length, and straightness of the connection hose, would have a minor effect (perhaps less than 20%) on the flow rate. You did use the term "initial flow rate", so it sounds like you already understand that the flow rate would decrease as the pressure in the tank decreases and (possibly) the pressure in the target container increases. The volume of the tank doesn't actually matter for finding the initial flow rate, but it will affect how quickly the pressure in the tank drops, which, in turn, affects how quickly the flow rate decreases. Similarly, the volume of the target container will also matter. Note that, for a flexible target container, like a balloon, a more complex relationship will exist between the quantity of gas and the back-pressure/flow rate. StuRat 22:52, 14 July 2008 (UTC)
How Can I Calculate the Stress of Saddle Clamp Bolts Supporting a Vertical Mast?[edit]
I need to calculate the stress of a saddle clamp bolt supporting a vertical mast to the side of a building.
For a vertical cantilever mast, such as an antenna or flag pole, force due to wind pressure on the antenna or flag will cause a moment around the mast base. The moment can be calculated by multiplying the force on the mast by the distance from the base to the force.
The stress on the mast at the base can be calculated by dividing the moment around the base by the section modulus of the mast.
I am dealing with a slightly different situation as shown in this diagram.
The upper saddle clamp has two bolts holding the mast to the building. To calculate the stress in a single bolt, can I simply substitute the section modulus of the bolt?
There is a reason why I ask this question for a single bolt -- not two bolts. When the force on the mast is such that it loads the bolts in tension, it's reasonable to expect each to carry about half of the load. When the force on the mast is such that is loads the bolts in shear, this may not be the case. The bolts do not fit precisely into the saddle clamp. It's possible that one bolt would need to deform before both bolts are carrying the load. Therefore, I think the conservative approach is to consider the load in shear of a single bolt.
Anyway, can I simply use the section modulus of the bolt to calculate the stress in the bolt in this scenario?
--xquercus 10:43, 12 September 2008 (UTC)
- I'd agree that you need to do your calculations as if a single bolt is present. See my diagrams below:
IF MAST IS VIEWED AS RIGID -------------------------- \ <- wind wind ->/ \ / \ +-+ /+-+ \ | | / | | \| | / | | +-+ +-+
IF MAST IS VIEWED AS FLEXIBLE ----------------------------- \ <- wind wind ->/ \ / \ +-+ /+-+ || | || | || | || | +-+ +-+
- So, if the mast is viewed as rigid, then, depending on the wind direction, most of the forces will apply either to the top or bottom bolt. If the mast is viewed as flexible, then the majority of the forces will always apply to the top bolt. In any scenario, we can't assume that the forces are distributed evenly. Therefore, I'd do the calculations for each bolt assuming that it's the only bolt. Otherwise, the bolt carrying the majority of the forces may fail, causing all the forces to apply to the second bolt, which may then fail as well.
- Now, as for the question about using the section modulus of the bolt to determine if it will shear; yes, that seems reasonable, when the bolt is under a shear load. However, with different loads on the bolt it may fail in different ways. The head of the bolt may break off or the threads of the bolt (or material into which the bolt is screwed) may also strip. Vibrations and/or a twisting load may also cause the bolt to unscrew over time, so it may be best to weld the bolt in place or at least use an adhesive ("thread lock") to prevent this. StuRat 15:47, 12 September 2008 (UTC)
- Thank you for your comments. I want to make sure I understand your comments and I may not have been clear. Each saddle clamp shown in the diagram has two hex bolts connecting the clamp and mast to the side of the building. When I refer to a single bolt, I am referring to a single hex bolt. The diagram above includes two sets of clamps, for a total of four bolts, as this is how I plan to do my installation. The following diagram includes a single clamp with a total of two hex bolts.
- I believe in the above diagram, the forces are a bit more complicated. For example, there may be some torsional forces in the bolts. Ignoring these forces, I believe when the bolts are in tension, we can reasonably expect the bolts to share the load. When the bolts are in shear, I don't believe the tolerances are close enough that the load will be shared evenly between the two hex bolts. Thus, a conservative maximum load should be determined by the strength of a single hex bolt in shear.
- As an aside, I've seen a general rule that the strength of a bolt in shear can be estimated by taking 60% of the strength in tension. I haven't found an authoritative source on this but am certainly looking for one.
- Thank you for reminding me of the potential failures at the head or threads. When doing my calculations, I've been using data from various ASTM standards which specify the yield strength of my bolts. I need to do a bit more reading to insure that the yield strength includes possible failure of the threads.
- My particular project is the installation of a vertical mast on the side of my house to support amateur radio antennas. I'm going through the entire process of calculating the maximum wind surface area the saddle clamps and bolts can handle using the Telecommunications Industry Association models for wind loading. The impact of a failure in this particular system is negligible however I'm preparing to erect a number of cantilever and guyed lattice towers. This exercise is a step in the learning process so I can understand the tower manufacturer's specifications and (if needed) my PE's calculations. --xquercus 23:53, 12 September 2008 (UTC)
- Thanks for the clarifications. I'm still unclear on the form of the mast itself, however. It appears to be cylindrical with no holes, in your diagrams, is this correct ? Your method seems good provided the bolts actually go through the mast, although there the mast itself will be considerably weakened by the holes, if the holes were drilled for this purpose, the mast now being subject to corrosion. It's difficult to tell if this is what was meant from the diagram. If they only go on either side of the mast and rely on friction with the clamp to keep the mast from sliding downward, then that would be a far weaker design. Perhaps the best method of all would be if the top pair of bolts went on either side of the mast (to preserve the strength of the mast where it will experience the strongest forces) and the bottom pair of bolts went through the mast (to support it):
| | +-----+-----+-----+ | / \ | | / \ | | \_/ | | \_/ | +-----+-----+-----+ | M | | a | | s | | t | | | | / \ | | \_/ | | | | / \ | | \_/ | | | +-----+
- A comment on the final rotation of the bolts: The bottom pair is in a good orientation, but it would be best if the upper pair were rotated so that the flats are parallel to the sides of the mast. This will prevent the corners of the bolts from putting unwanted force concentrations on the bracket. Since it may be difficult to control the final rotation of the bolt heads, using circular washers between the bolt heads and bracket may be a better way to accomplish this. Ensure that the washers are wider than the corners of the bolt heads.
- One last question, what material do the bolts screw into ? Beware that this material itself may fail, in that the bolts may strip out of it, or a piece of the material may break off, or the material may crack, or the entire piece may break off of the building (for example, if a bolt is screwed into a brick). If possible, arrange it so that each bolt screws into a different object, to distribute the forces widely. Attaching to the frame of the building would be the best way to go.
- Beware that certain combinations of metals cause corrosion since one material acts as an anode and the other as a cathode. If you are near salt-water, special precautions will be needed for dealing with salt-water spray. Painting the bracket, bolts, washers, and mast (near the holes) with an outdoor paint may help to slow failure due to corrosion. Also, be sure to use hardware rated for outdoor use. The antenna mast will also need to be grounded to protect the house from lightning strikes. StuRat 10:09, 13 September 2008 (UTC)
Helium flow rate compared to argon[edit]
I'm trying to control a helium (97%, air 3%) tank using a flowmeter calibrated for argon. From rough experiments it seems that the helium is flowing at about 2.5x the marked rate. Is there a general theoretical reason that would confirm or correct this number, or would it depend largely on the specific configuration of the equipment? (Or maybe this is a chemistry question?) Cheers, Lsterling 03:52, 24 October 2008 (UTC)
- I'd say experimental methods are probably the best way to establish the different flow rates. Differences will be caused by the atomic masses of the elements, the radius of the atoms (which depends on the electron configuration), what molecules they form (monoatomic or diatomic, for example), any charge they have, etc. You could theoretically combine all this info together to come up with a flow rate, but it sounds like more work than the experimental method, to me. StuRat 02:16, 28 October 2008 (UTC)
- The first thing to ask is what type of flow-meter is this? Is it a magnetic, optical or manometric (pressure-based) meter? Various things will foul up the readings of each of these types of meters. Calculate viscosity to evaluate how much these vary. Similarly, evaluate temperature. If any one of these varies much from the other... Density will screw-up magnetic and manometric flow-meters while turbidity or impurity may easily disrupt optical flow measurements. --71.137.197.23 02:15, 15 December 2008 (UTC)
Mechanical joint problem[edit]
Note: I'll do my best to make this clear, but I can't promise anything.
I'm having troubles engineering a joint for the following scenario:
Imagine two equal-length arms (flat steel) that are connected to one another by a pivot point where they meet. They are in the same line, similar to clock hands at 25 past 11. Now, there is a force applied to the minute hand that rotates it anti clockwise. The joint ensures that the hour hand turns with it, so that they are still in the same line at 20 past 10. At this point, the join allows the minute hand to continue to turn until pointing at 2, while the hour hand remains at 10.
On the return (the minute hand is spring loaded to return when no force is applied), the minute hand moves from 2 to 3 turning the hour hand with it (back to its starting position). When the minute hand reaches 4, it then moves on its own (ie the hour hand is now stationary) back to 5.
Essentially the motion goes like this:
Force applied: Both move - minute hand moves alone
Force not applied (returning to starting position): Both move - minute hand moves alone.
- It sounds like you need some absolute limits on the motion of the "hour hand", such as stops extending up from a face plate below the hour hand. Then you could have some rubber "blades" (like the blades of a windshield wiper) that extend down from the minute hand and up from the hour hand. Those will cause the two hands to move together until they hit a stop. Here's a pic that shows the stops and an exploded view of the hands in the 12 o-clock position:
+-----+ | MIN | +--+--+ | RUBBER BLADES -> END | VIEW +-+ +--+--+ +-+ | | |HOUR | | | |S| +-+P+-+ |S| ++T+------------+I+------------+T++ | O |V| FACE O | | P |O| PLATE P | +---------------+T+---------------+ +-+
+---------------------------------+ | | | +-----+ | |\ | M H | /| | \ | I O | / | | LEFT | N U | RIGHT | | STOP | R | STOP | TOP | | | | VIEW | | | | | | | | | | | | T B | | | | O T | FACE | | | P M | PLATE | | | O | | | |PIVOT| | | +-----+ | | | +---------------------------------+
- The face plate can be minimized considerably to only extend to the stops, so long as it's anchored so it can't move when the hour hand moves.
- Note, on rereading your question, I think I may have misunderstood. It sounds like you may want the two hands to move together at times when they aren't directly on top of each other. Is that correct ? If so, I'll need to come up with a modified design. Perhaps the stops can remain, but the rubber blades can be replaced with circular plates on the hour and minute hands, near the pivot, such that they contact each other with a moderate amount of friction (enough so they move together normally, but can move separately when the limits are reached on the hour hand). A way to have friction between the plates, without wearing them our quickly, would be to use a very thick grease between them. This would work as long as this mechanism doesn't move very fast, in which case heat could build up. StuRat 20:21, 10 December 2008 (UTC)
Pressure Drop Across a Constricted Annulus and the Venturi Effect[edit]
I am looking at a pump wear ring application, think of a concentric ring on a shaft with a clearance gap between the shaft and ring.
My question is this:
Due to any venturi effects, can the pressure profile in the clearance gap ever be less than the pressure on either end of the ring (entrance and exit)?
The differential pressure across the ring is 100 psi with the actual pressure numbers varying depending on what stage of the pump you are looking at.
_______________ | | A |______________| B ____Clearance Gap______ | | | | | | ------- -- -- ---------
Pressure A = 200psi (for example)
Pressure B = 100psi (for example)
(All flow must go thru the clearance gap)
Shaft diameter = 4.000 in
Ring inner diameter = 4.012 in
- I think you're right, the venturi effect does apply here, so the pressure could be lower than 100 PSI, probably close to the 100 PSI side. StuRat 06:16, 13 February 2009 (UTC)
I NEED HELP PLEASE!!!!!!!!!!!!!!!!!!! (Bird house)[edit]
I have constructed a Martin birhouse 2'x2'x2' and it weighs 30 pounds. It is mounted on top of a 16' pressure treated 4"x4" post. I now need to have the bottom of the post 2' off the ground and erect it vertical ( so the birds will come live in it). I figure I need to use concrete and some more lumber. But how??? so mother nature won't destroy it????
HELP!!!!HELP!!! PLEASE!!! My name is Paul
- Perhaps the biggest threat will come from animals trying to get to the martins, their eggs, and any food they have in their house. Unfortunately, just about any animal can climb a wooden post (maybe not dogs), so a metal pole would be a better choice. That would discourage most animals, and you could even grease the pole if some keep trying to climb it. One other problem with a square, wooden post is that it may cause the unit to fall over in heavy winds. A circular pole with a smaller diameter would greatly reduce this effect.
- But, let's assume you're stuck with the square, wooden post. My suggestions for mounting it are as follows:
1) Get a metal pole to mount into the ground and in the center of the square, wooden post. Perhaps a 6 foot long metal fence pole would work, if you expect 2' in the ground, and 4' above (with 2' of those 4' inserted into the square, wooden post).
2) Drill a hole in the end of the post for the pole, and test it to make sure the wooden post slides nicely over the metal pole, all the way in. You may need a special tool to drill this hole. If so, go to a home improvement store and ask. They may either rent you the tool or drill the hole for you. Obviously, it's very important that the hole be vertical and in the center.
3) Dig a hole for the metal post and concrete. The same home improvement store will probably rent fence-pole-hole digging equipment. You can also dig the hole with a shovel, but that requires more work and concrete as the sides will be more like a 45 degree angle using a shovel. The hole should go below the frost-line for your area, so you won't get W:frost heaving, which can cause the bird house to lean.
4) Place the metal pole in the final position, stuck in the dirt at the bottom of the hole. Use stakes and ropes to tie the pole into it's final position, and use a level on top to ensure that the pole is truly vertical. Avoid doing this on a windy day, as it will be more difficult to keep the pole stationary while the concrete sets.
5) Get some concrete and follow the instructions very carefully. The mix of ingredients is critical, as is the temperature, humidity, etc. You also must use it fairly quickly after you mix it, and must rinse off any tools or containers before the concrete hardens on them.
6) After you pour the concrete, wait the recommended amount of time for it to set, then place the wooden post over the metal pole. This may take two people. This design may allow the bird house to be rotated (depending on the shaft/hole tolerance). I'd think you would want to rotate it so the opening is pointing away from the prevailing winds, to make it the nicest for the martins. It should stay in position normally, but extreme winds may rotate it, in which case you can rotate it back. StuRat 15:22, 1 April 2009 (UTC)
microprocessor based EPROM programmer[edit]
Hello. Any one interested in this learning project? or if anyone has completed this project contact me ASAP by sending me a mail on jigsaw.18june@gmail.com or post it here
thanks
Below is the project statement :.
Reply 1: Though you need to be more specific about what problems are you facing. This is a common university project, and can be accomplished with many microcontrollers - starting from the simplest 8051 core to more complex uC available today.
Manufacturing steel tubes[edit]
Friends, I am new to this portal and i have a very specific question in my mind.Which is the best method to manufacture hollow steel tubes of about 8 mm internal diameter & 40 mm outer diameter. the answer to this question is important to me as this has got connected to my livlihood now. hope to get answers from you all soon.thanks & regards ajay.
- Let's look at some ways to form tubes and determine which might work for you:
- 1) Start with flat sheet metal, then bend it into a tube and weld the seam. This is appropriate for thin-walled tubes, though, not for yours.
- 2) Cast each section in two pieces, then weld them together. Probably not appropriate for tubes made to withstand high pressures, as the welds may fail (or the metal right around the welds).
- 3) Start with a solid cylinder, then drill out the hole. This would be appropriate for thick-walled tubes with small inner diameters and short length. You didn't specify the lengths needed.
- 4) Extrude the tube with the hole inside it. The supports for the bullet shaped form used to create the hole will sever the tube wall, so it will need to be hot enough to rejoin after. This method can be used to form very long tubes. Here's a rough drawing of what the center of the form for the extrusion might look like, with 3 supports:
FRONT SIDE / |\ - O | > \ |/
- So, I'd expect the 4th approach would work the best for you, although the 3rd could also work for short tubes and the 2nd could work as long as the pressure requirements aren't very high. StuRat 05:19, 14 April 2009 (UTC)
How to tolerance a bolt hole given the bolt size and free fit?[edit]
Grain Growth[edit]
I have no idea how to start this. Please help! Grain growth rate (change in grain size with time) is proportional to the inverse of the grain size (the change in area is the critical parameter, but the linear rate will be normalized to the volume). Based on this fact derive the grain growth equationwhere n=2. (d^2-do^2=Kt)
Underwater ROV[edit]
UNDERWATER ROV I need to come up with an idea on a ROV that can go down to the bottom of a pool and collect 125 mL of water and then bring it back up. Any ideas??!!
How to calculate the temperature change of fluid inside a casing[edit]
Hi Everyone,
I am attempting to calculate the temperature of a casing circulating fluid that is heated from the formation. After reviewing articles from the Society of Petroleum Engineers such as: SPE 3605, SPE 1484, and SPE 105437, the answer was not clear. The following is an example question that I have gathered information from SPE 1484.
Fluid = water Casing Inner Diameter = 4.892 inches Casing Outer Diameter = 5.50 inches Fluid thermal conductivity = 0.37 BTU/(foot * Fahrenheit) Fluid Density = 8.34 pounds per gallon Formation specific heat = 0.21 BTU/(pounds * Fahrenheit) Formation thermal conductivity = 1.30 BTU/(foot * Fahrenheit) Formation temperature = 160 Fahrenheit Water temperature prior to exposure = 100 Fahrenheit Section of pipe = 10 feet
There are a few formulas at that is:
How would I determine the temperature of the fluid inside the casing after 1 minute of contact time?
Thanks for your help!
Are Velocity (mm/s) measurements obtained using an accelerometer comparable to those obtained using a Geophone?[edit]
I have performed some ground borne vibration tests using an accelerometer and obtained mm/s data (the vibration meter has a Velocity filter incorporated). I have noticed the results I'm getting are different from another geophone instrument I am also using in a comparative style. Are the peak velocity measurements I'm obtained from my accelerometer not analagous to those Peak Particle Velocity (PPV) measurements my geophone is yielding? Does a correction need to be applied? The accelerometer results are significantly greater than those from the geophone. | https://en.wikiversity.org/wiki/Engineering_Help_Desk | CC-MAIN-2019-43 | refinedweb | 5,259 | 69.11 |
Archive for the ‘Kit’ Category
Watch the satnav
The Mashup Spectrum
Having owned a ZX Spectrum and being part of a generation that got into computers as a result (along with owners of the BBC Micro, the Commodore 64 and the like), my attention was drawn to this ZX Spectrum Laptop (via Endgadget.) In an ideal world – a world unencumbered by constraints – the OS would have been the Spectrum OS. I wonder what other retro inspired hardware mashups are out there or being built right now.
iPhone ads
Don’t watch these adverts. You’ll want one. You have been warned.
Monkeying around
Over the last couple of days I’ve got nspectre working under Mono. I hope to be able to release a patched version later this month. Here’s how I got it to work. I installed NAnt 0.85 on Ubuntu 6.10 (which I run in Parallels.) I found this link via Cory Foy that shows how simple it is to install NAnt on Mono.
UPDATE: At this point I built TemplateEngine. I used MonoDevelop to build it – no issues to report.
With Nant up and running, I created a build script for NSpectre. To get started, the build script only builds NSpectre.Core, NSpectreExample and NSpectreExample.Entities. Once I had these compiled (on my set up, the csc task in NAnt targets gmcs by default – very impressed), I ran them.
And ran into problem number 1. It appears that Mono implements Assembly.Load differently to .NET. See here for further detail. As a short term fix, I modified ResourceLocator by adding a type initialiser to load all assemblies in the bin directory. I’ll take another look at this, there may be a better way of doing it, but for now it works.
Problem number 2. I set NAnt to use dynamic prefixing for the resources. The namespaces it uses are different to those that VS .NET would use – VS .NET would use the project namespace as the root namespace, whereas Nant uses the name of the folder that contains the project (for subfolders the behaviour is the same.) Pretty easy to fix – modified references in code and config files to use the NAnt generated namespaces.
Problem number 3. One hardcoded (a constant) backslash (used in Engine.) Oops. Modified to a forward slash for the purposes of getting it to work.
Problem number 4. NSpectreExample uses Win32 API calls to change the foreground colour of the console (.NET 2.0 supports this in managed code, so this won’t be a problem in the future.) Unsurprisingly, Win 32 API calls don’t work in Linux. So, I commented these lines out for now.
And that’s it. OK, so there were a few more issues along the way. But the other issues were about getting the build script “right” – in this case getting the csc tasks to build nspectre as closely to the way VS .NET does as possible.
So, a little more investigation, some minor modifications, some clean up of the build script and I’ll be able to release a Mono’ed version of nspectre.. | https://remark.wordpress.com/category/kit/ | CC-MAIN-2016-40 | refinedweb | 522 | 76.72 |
I am currently taking a introductory Java class at school, and we have been assigned to do a project, which i chose to do a tic tac toe game. THEN he said it must use GUI...says the professor who hasn't taught us anything about GUI besides what a 8 year old could figure out. He told the class to Google our project, and unbelievably he said to copy a code off of the web that someone else had already done, well that's very helpful as a lot of the codes about such a project we don't understand in the first place, let alone implementing GUI into them.
i got a code and I've looked it over and messed around with it for awhile now and I mostly understand how it works, without using GUI. I am now trying to use GUI for setting the prompts (i.e Various messages such as the rules of the game, which of the two players won or whether it was a draw, asking the user the player's name, what marker they will play with etc.) and i am having trouble. When the dialog box appears and i input the player's name, it will not send it to the other class, i'm sure it's not that complicated but I've been looking through our book and can't find anything close to being helpful. I greatly appreciate any help. I, as well as the rest of my class, are just way over our heads on this. i know i could just Google tic tac toe using GUI, but I'm trying to actually learn this, since i'm majoring in computer science, i want to learn it, not just copy and paste it.
Here is my Main class:
Code:package com.javadb.tictactoe; import javax.swing.*; import java.awt.*; import javax.swing.JOptionPane; public class Main { public void play() { String P1, P2; TicTacToe game = new TicTacToe(); // This displays the rules of the game in a pop up text box and has no input. String message = String.format("Welcome! This game requires two players, GRAB A FRIEND!\n\nPlayers take turns marking a square with their respective letter.\n\nOnly squares empty squares can be selected.\n\nOnce a player has selected three squares in a row, the game is over and they are declared winner!\n\nIf all squares are marked with neither player having a series of 3 consecutive squares (horizontal, vertical, or diagonal), the game ends resulting in a draw.\n" ); JOptionPane.showMessageDialog(null, message ); //this is where I started to change it into GUI, the user inputs his name into a textbox, but I connot figure out how to set that input, saved here as String P1, to Player1 for the other class to capture. P1 = JOptionPane.showInputDialog("Enter player one's name:" ); game.setPlayer1(game.getPrompt()); P2 = JOptionPane.showInputDialog("Enter player two's name" ); game.setPlayer2(game.getPrompt()); boolean markerOk = false; while (!markerOk) { String message3 = JOptionPane.showInputDialog( "Select a letter to use as " + game.getPlayer1() + "'s marker: " ); String marker = game.getPrompt(); if (marker.length() == 1 && Character.isLetter(marker.toCharArray()[0])) { markerOk = true; game.setMarker1(marker.toCharArray()[0]); } else { String message4 = JOptionPane.showInputDialog( "Invalid marker, try again." ); } } markerOk = false; while (!markerOk) { String message5 = JOptionPane.showInputDialog( "Select a letter to use as " + game.getPlayer2() + "'s marker: " ); String marker = game.getPrompt(); if (marker.length() == 1 && Character.isLetter(marker.toCharArray()[0])) { markerOk = true; game.setMarker2(marker.toCharArray()[0]); } else { String message4 = JOptionPane.showInputDialog( "Invalid selection, please retry." ); } } boolean continuePlaying = true; while (continuePlaying) { game.init(); System.out.println(game.drawBoard()); System.out.println(); String player = null; while (!game.winner() && game.getPlays() < 9) { player = game.getCurrentPlayer() == 1 ? game.getPlayer1() : game.getPlayer2(); boolean validPick = false; while (!validPick) { String message5 = String.format( "It is " + player + "'s turn. Pick a square (1-9): "); JOptionPane.showMessageDialog(null, message5 ); String square = game.getPrompt(); if (square.length() == 1 && Character.isDigit(square.toCharArray()[0])) { int pick = 0; try { pick = Integer.parseInt(square); } catch (NumberFormatException e) { //Do nothing here, it'll evaluate as an invalid pick on the next row. } validPick = game.placeMarker(pick); } if (!validPick) { String message6 = String.format( "This square can not be selected. Please try again."); JOptionPane.showMessageDialog(null, message6 ); } } game.switchPlayers(); System.out.println(); System.out.println(game.drawBoard()); System.out.println(); } if (game.winner()) { String message6 = String.format( "Game Over - " + player + " WINS!!!"); JOptionPane.showMessageDialog(null, message6 ); } else { String message7 = String.format( "Game Over. Draw :( "); JOptionPane.showMessageDialog(null, message7 ); } System.out.println(); String message8 = JOptionPane.showInputDialog( "Would you like to play again? Y/N"); String choice = game.getPrompt(); if (!choice.equalsIgnoreCase("Y")) { continuePlaying = false; } } } public static void main(String[] args) { Main main = new Main(); main.play(); } }
This is the TicTacToe class, which is the game dynamics:
Code:package com.javadb.tictactoe; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class TicTacToe { private char[][] board = new char[3][3]; private String player1; private String player2; private int currentPlayer; private char marker1; private char marker2; private int plays; private BufferedReader reader = new BufferedReader(new InputStreamReader(System.in)); protected void init() { int counter = 0; for (int i = 0; i < 3; i++) { for (int i1 = 0; i1 < 3; i1++) { board[i][i1] = Character.forDigit(++counter, 10); } } currentPlayer = 1; plays = 0; } protected void switchPlayers() { if (getCurrentPlayer() == 1) { setCurrentPlayer(2); } else { setCurrentPlayer(1); } setPlays(getPlays() + 1); } protected boolean placeMarker(int play) { for (int i = 0; i < 3; i++) { for (int i1 = 0; i1 < 3; i1++) { if (board[i][i1] == Character.forDigit(play, 10)) { board[i][i1] = (getCurrentPlayer() == 1) ? getMarker1() : getMarker2(); return true; } } } return false; } protected boolean winner() { //Checking rows char current = ' '; for (int i = 0; i < 3; i++) { int i1 = 0; for (i1 = 0; i1 < 3; i1++) { if (!Character.isLetter(board[i][i1])) { break; } if (i1 == 0) { current = board[i][i1]; } else if (current != board[i][i1]) { break; } if (i1 == 2) { //Found winner return true; } } } //Checking columns for (int i = 0; i < 3; i++) { current = ' '; int i1 = 0; for (i1 = 0; i1 < 3; i1++) { if (!Character.isLetter(board[i1][i])) { break; } if (i1 == 0) { current = board[i1][i]; } else if (current != board[i1][i]) { break; } if (i1 == 2) { //Found winner return true; } } } //Checking diagonals current = board[0][0]; if (Character.isLetter(current) && board[1][1] == current && board[2][2] == current) { return true; } current = board[2][0]; if (Character.isLetter(current) && board[1][1] == current && board[0][2] == current) { return true; } return false; } //this is where i belive my problem is coming from, as i don't completely understand the purpose of this method. protected String getPrompt() { String prompt = ""; try { prompt = reader.readLine(); } catch (IOException ex) { ex.printStackTrace(); } return prompt; } protected String drawBoard() { StringBuilder builder = new StringBuilder("Game board: \n"); for (int i = 0; i < 3; i++) { for (int i1 = 0; i1 < 3; i1++) { builder.append("[" + board[i][i1] + "]"); } builder.append("\n"); } return builder.toString(); } public int getCurrentPlayer() { return currentPlayer; } public void setCurrentPlayer(int currentPlayer) { this.currentPlayer = currentPlayer; } public char getMarker1() { return marker1; } public void setMarker1(char marker1) { this.marker1 = marker1; } public char getMarker2() { return marker2; } public void setMarker2(char marker2) { this.marker2 = marker2; } public int getPlays() { return plays; } public void setPlays(int plays) { this.plays = plays; } // I understand that this getPlayer1() mehtod calls from the other class game.setPlayer1() to obtain the input from the user. public String getPlayer1() { return player1; } //then this changes the input into the private String called player1 public void setPlayer1(String player1) { this.player1 = player1; } public String getPlayer2() { return player2; } public void setPlayer2(String player2) { this.player2 = player2; } } | http://forums.devshed.com/java-help-9/set-method-943125.html | CC-MAIN-2014-23 | refinedweb | 1,250 | 52.15 |
In this article we are going to see how to create a user control in ASP.NET. Advantage of using a User Control
Steps to Create User Control
1. Go to File -> New -> Project
2. Type the required name for the user control and click Add Button.
3. You will get the markup for SampleUserControl.ascx shown below.
<%@ Control Language="C#"
AutoEventWireup="true"
CodeBehind="SampleUserControl.ascx.cs"
Inherits="UserControlSample.SampleUserControl" %>
4. You will get the code behind as following.
namespace UserControlSample
{
public partial class SampleUserControl : System.Web.UI.UserControl
{
protected void Page_Load(object sender, EventArgs e)
{
}
}
}
5. Now add you controls into the User controls. Controls like TextBox and Label show a simple example. Note Controls can be placed just below the Control directive.
6. Register the User control in a web page. Use just next to page Directive.
Src="SampleUserControl.ascx"
TagName="MyControl"
TagPrefix="uc1" %>
Src - User Control page name with extension.TagName - Tag name can be any name, this is user defined. TagPrefix - Can be any prefix, this is user defined.
7. Register and add a user control in a web page then run the default.aspx page.
8. Embedded output of web page:
This is very useful for reducing duplicate code and helps to reuse the control and save time in retyping the code.
How to Get Data From DataList Using Stored Procedure and Pagination of the DataList Control
Dynamically Loading UserControl Into Web Page Using ASP.NET
nice and easy....
Hi, Arun It's a great effort and really very helpful for beginners, So keep it up and thanks for sharing.........
Hi, This article is so good keep it up... | http://www.c-sharpcorner.com/UploadFile/d3e4b1/practical-approach-of-creating-user-control-in-Asp-Net/ | CC-MAIN-2013-20 | refinedweb | 274 | 60.82 |
Learning GNU C
From IPRE Wiki
Learning GNU C Ciaran O'Riordan
This file is a C programming tutorial using the GNU C compiler and GNU Lib no Invariant Sections, with the Front-Cover Texts being "Richard Stallman Rules", and with the Back-Cover Texts being "This is a Free book, Free as in Freedom. Permission is granted to copy, distribute, and edit this book under the GNU Free Documentation License".
Notes:
Preface
Target Audience
Welcome to Learning GNU C. The aim of this book is to teach GNU users how to write software in C. It is written primarily as a tutorial for beginners but should be thorough enough to be used as a reference by experienced programmers. The basics are laid down in full in the first few chapters. Beginners will read these chapters carefully while those with prior experience can skim through them. All the information is there, no prior knowledge of programming is assumed.
The reader is assumed to have access to a computer with a GNU system installed. Although the target audience is GNU users, the content of the book should also be 98% relevant to users of OpenBSD, FreeBSD, or NetBSD. Some familiarity with using your computer from the shell (the command line) would be helpful, although all commands will be shown alongside programming examples. The only piece of software you do need experience with is a text editor. Any text editor will do. GNU Emacs is an especially good one for programmers. It has been in development for over twenty years and contains hundreds of useful features. GNU Nano is a simple text editor you could use. Some programmers like to use vi (pronounced 'vee eye'). If you already have a favorite text editor, you can use that. There are also graphical editors geared towards programmers such as Anjuta and KDevelop, but most programmers prefer text based editors.
Scope of this text
The contents of this book can be divided into two topics: the core C language, and the standard functionality made available to the programmer. The standard functionality I mention is provided by GNU Libc. This is a library of C functionality that is part of every GNU system. Neither of these topics is of much use without the other but there is a focus on the core language near the beginning and more discussion on Libc near the end. The ordering of topics is designed to teach C programming in an incremental fashion where each chapter builds on the previous one. Some aspects of the core language are only really of use to experienced programmers and so appear near the end.
The C language on its own can make decisions, repeat commands, store data, and perform mathematics. Equally importantly, it provides a method to make use of extra functionality such as Libc.
Libc provides functionality such as reading and writing files, sorting and searching data, getting input from the user, displaying data to the user, communicating across networks, creating easily translatable programs, and many other things.
Why learn C?
C is a standard. It is the programmers' programming language. It is the standard programming language of GNU and BSD-based systems. The majority of these systems and the applications that run on them are written in C. C was developed over thirty years ago for writing operating systems and applications. Its small, extensible design has allowed it to evolve with the computer industry. Because of its age and popularity, C is a very well supported language. Many tools exist to make C programming easier and these tools are often very mature and of a high standard. All the software we will use in this book is written in C.
Why use GNU?
GNU is a complete, Unix-like operating system that has been in development for just over twenty years. GNU software is known for its stability and standard compliance.
Most GNU systems use Linux as a kernel. These systems are often known as GNU/Linux systems.
Why Free Software?
The greatest thing about GNU is that the entire system is what is known as Free Software. Software is Free Software when people have the freedom to: use the software for any purpose, make changes to the software, share the software with others, and distribute modified versions of the software.
Software that isn't Free Software is called proprietary software. It is so-called because a person claims the software to be their property and bans others from sharing and making changes to it.
From an ethical standpoint, writing Free Software is a much more social way to act. Free Software empowers its users by allowing them to help themselves by making changes they want to the software (or getting someone else to make these changes). It allows people to help their neighbors by sharing the software. Proprietary software does the opposite: it makes sharing illegal, telling people that it is a criminal offense to say "yes" when someone asks for help. And Free Software allows people to help their community by distributing improved versions of the software.
Free Software also doesn't discriminate against poorer people or people from developing nations. By allowing them all the above freedoms it permits them to use computers without having to pay impossible amounts of money for the "privilege".
Finally, there are the technical benefits. Free Software is free from marketing plots. It doesn't restrict itself to force users to buy extra pieces of software. Each piece of GNU is designed to be as useful as possible. As a programmer, you can use the same C programming software that is used in major projects.
Non-Free programs are generally distributed in a machine readable form only. This means that the user cannot see what is going on inside a program. In contrast, Free Software is required to come with source code in a human readable format. As a programmer, you can read the source code for any piece of Free Software you like. If there are errors in a program, you can fix them.
This freedom to fix errors and add functionality is what has made GNU software so good. All code is available for peer review.
Free Software will change the world for the better
Introduction to C
What are Programming Languages?
A programming language defines a format for laying out ordered sets of instructions to be executed by a computer. Programming languages can be sorted into three three categories: interpreted languages, compiled languages, and machine languages. Of these types, only machine languages can be understood directly by a computer.
A machine language languages. its own machine language and, therefore, its own assembly language. The next task was to design a language that could be translated into the machine language of many CPUs.
These new machine-independent languages were known as third generation or high-level languages. Designed to be easy to read, these languages were made up of English words, basic mathematical symbols and a few punctuation characters. These languages allow simple statements to be expressed concisely, for example, adding two numbers and storing the result in memory could be expressed as:
data = 10 + 200;
rather than:
Load R1, 10 Load R2, 200 Addi R1, R2 Store R2, L1
What is C?
A tool called a compiler is
And the program in C:
#include <stdio.h> int main() { int wages = 1000; int tax_allowance = 400; float tax_rate = 0.22; int tax_due; tax_due = (wages - tax_allowance) * tax_rate; printf("Tax Due: %d euro\n", tax_due); return 0; }
Which did you find easier to understand, even without knowing C? The output of both programs is the same: "Tax Due: 131 euro". The Assembly code shown is written in the "80386" instruction set and will not work on machines that use a different instruction set. The C code can be compiled for practically any computer.
Programming Tools
GNU comes with a compiler called GCC. Originally, this stood for "GNU C Compiler" but since it can now compile languages other than C, its name was changed to "GNU Compiler Collection". To check if you have GCC installed, type the following:
ciaran@pooh:~/book$ gcc --version gcc (GCC) 4.1.2 20070925 (Red Hat 4.1.2-27) Copyright (C) 2006 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ciaran@pooh:~/book$
The version of GCC you have installed may be different, anything similar, such as "2.95.2" or "3.3.0", is ok. If you get.
Introducing GCC
Now we're going to show you a tiny bit of C code and how to compile it. The point here is to show you how to use GCC so we won't explain the C code yet. Here's the smallest C program that GCC will compile. It does nothing.
Example 1-2. tiny.c
main() { }
Type this piece of code into your text editor and save it to a file called tiny.c. You can choose any name so long as it ends with .c. This is the extension used by C programs, and GCC checks for this extension when compiling a program. With the file saved, you can now compile it into an executable program by typing:
ciaran@pooh:~/book$ gcc tiny.c ciaran@pooh:~/book$
This command should succeed with no output. If you got any error messages, check that you typed the program in correctly. Weighing in at eight characters, we'll assume you've gotten this much correct and move on. A file called a.out should have appeared in your directory. This is the machine language program created from the above code. If you run it you will see that it really does nothing at all. The name a.out exists for historical reasons, it is short for assembler output.
Although GCC will compile this code, it isn't strictly complete. If we enable GCC's warnings, we will be told what is missing. You are not expected to understand the warning messages right now, we show this only to demonstrate GCC's warnings. You enable warnings by adding the -Wall switch to your compilation command.
ciaran@pooh:~/book$ gcc -Wall tiny.c tiny.c:2: warning: return-type defaults to `int' tiny.c: In function `main': tiny.c:3: warning: control reaches end of non-void function ciaran@pooh:~/book$
These warnings appear because our program is not strictly complete. To get rid of these warnings we must add two more lines. So here's the smallest valid C program:
Example 1-3. tiny2.c
int main() { return 0; }
When we compile this with the -Wall option we will get no warnings. Another option: -o filename can be used to specify the name you want to give to your program (instead of a.out).
ciaran@pooh:~/book$ gcc -Wall -o tiny-program tiny2.c ciaran@pooh:~/book$ ls tiny2.c tiny-program ciaran@pooh:~/book$ ./tiny-program ciaran@pooh:~/book$
Who defines Valid C?
For you, the programmer, "valid C" is defined by the compiler. There are many dialects of C in existence, thankfully they are all very similar. There are also other languages that are based on C such as Objective C and C++. These languages are very like C in their appearance, but their usage is quite different. GCC understands many dialects of C as well as many other languages (including Objective C and C++).
"K, and GCC supports it only for compiling very old programs. We mention it here purely for historical purposes.
ISO C
In 1983, the American National Standards Institute (ANSI) set up a committee to draw up a more exact standard and fix a few shortcomings they saw in the language. In 1989, they finalized this standard which was accepted by the International Standards Organization (ISO). This new dialect became known as "C89". It is also called "ISO C" or "ANSI C". GCC is one of the most conforming compilers available.
C99.
Choosing a Dialect.
Future Standards.
Conclusion
This concludes our introduction. Hopefully, you now have a grasp of what programming is. In the next chapter we'll start writing basic programs that actually do something and explain how they do it.
Starting With Functions
What are functions?
Functions:
Example 2-1. hello.c
#include <stdio.h> int main() { printf("hello, world\n"); return 0; }
Compile and run this program before moving on. If all goes well, it will display the text string .
A Line-by-Line Dissection
We'll do a quick description of what each line does. Don't worry if you're not sure about some parts, we'll do plenty more examples.
#include <stdio.h>
This line tells GCC to.
int main()
This line begins the definition of the function main(). We'll explain the first of these two lines later.
{
The open curly braces signals the beginning of a block of code. All code between this curly brace and its matching closing brace is part of the function main().
printf("hello, world\n");
This line is a function call, the function is already defined for you. When you call printf(), you must pass it an argument to tell it what to display.
return 0;
The return statement ends execution of the function main(), any statements after this line would not be executed. When main() ends, your program exits. When a function ends, it can pass a value back to whoever called it. This is done by placing the value after return. main() always returns an integer (a positive or negative number with no decimal point). We tell the compiler to expect this by preceding the definition of main() with int. When returning from main(), it is convention to return zero if no problems were encountered.
}
The closing curly brace signals the end of the block of code that makes up main().$
Comments are a way to add explanatory text to your program. They are ignored by the compiler, so they don't affect your program in any way. As the programs you write get larger, you will find it helpful to have comments in your code to remind you what you are doing. In the examples in this book we will use comments to explain what is going on. There are two ways to insert a comment into your program, the most common way is to start and end your comments with /* and */ respectively. Comments of this sort can span multiple lines. The second way is by placing // at the start of your comment. Comments of this sort are terminated at the end of a line. Here's our "hello, world" program with comments.
Example 2-2. hello2.c
/* The purpose of this program is to * display some text to the screen * and then exit. */ #include <stdio.h> int main() { /* printf() displays a text string */ printf("hello, world\n"); return 0; //zero indicates there were no errors }
When compiled, this code will produce exactly the same executable. Lines 2 and 3 of the comment at the top start with an asterisk. This is not necessary, but it makes it clear that the comment extends for four lines.
Making Your Own Functions
In that last example we defined just one function. To add another function you must generally do two things. First, you must define the function, just like we defined main(). Also, you you must declare it. Declaring a function is like telling GCC to expect it. We didn't have to declare main() because it is a special function and GCC knows to expect it. The name or identifier you give to a function must appear in both the definition and the declaration.
Function identifiers can be made up of the alphabetic characters "a"-"z" and "A"-"Z", the numeric characters "0"-"9" and the underscore character "_". These can be used in any order, as long as the first character of the identifier is not a number. As we said earlier, C is case-sensitive, so My_Function is completely different from my_function. A function identifier must be unique. Identifiers can safely be up to 63 characters long or as short as 1 character.
Along with its identifier, you must give each function a type and a block of code. The type tells the compiler what sort of data it returns. The return value of a function can be ignored. printf() returns an integer saying how many characters it displayed to the terminal. This information wasn't important to us, so we ignored it in our program. In the next chapter we'll discuss types of data in detail. Until then we'll gloss over return values.
Here's a program that defines three functions:
Example 2-3. three_functions.c
#include <stdio.h> /* function declarations */ int first_function(void); int goodbye(void); int main() { // function definition printf("the program begins...\n"); first_function(); goodbye(); return 0; } int first_function() { // function definition /* this function does nothing */ return 0; } int goodbye() { // function definition printf("...and the program ends.\n"); return 0; }
In the above example we wrote first_function(), which does nothing, and goodbye(), which displays a message. Functions must be declared before they can be called. In our case, this means they must appear before our definition of main(). In practice, function declarations are generally grouped at the top of a file after any #include lines and before any function definitions.
2.5. Multiple Files
Programs do not have to be written in just one file. Your code can split up into as many files as you want. If a program is comprised of forty functions, you could put each function into a separate file. This is a bit extreme though. Often, functions are grouped by topic and put into separate files. Say you were writing a program that worked out the price of a pizza and displayed the result. You could put the calculation functions into one file, the display functions into another, and have main() in a third one. The command you would use to compile your program would look something like this:
ciaran@pooh:~/book$ gcc -o pizza_program main.c prices.c display.c
Remember: If you define a function in prices.c and you want to call this function in main.c, you must declare the function in main.c.
Header Files
Keeping track of function declarations can get messy. For this reason, header files are used to house C code that you wish to appear in multiple files. You have actually already used a header file. stdio.h is a header file which contains many function declarations. It contains the function declarations for printf(). Once you have placed the function declarations you wish to share into a header file, you can #include your header in each C file that needs the information. The only difference is that you surround your filename in quotes instead of angle brackets ("my_header.h") instead of (<system_header.h>). To illustrate these points, we'll write that pizza program I mentioned earlier.
A Larger (non)Program
The small amount of programming we have shown so far isn't enough to make a decent interactive program. To keep it simple, we will write just a skeleton program so you can see the structure and usage of header files without getting bogged down in new concepts. In Chapter 3 we will write a full version of this program. The code here can be compiled and run, but it will not ask the user for any input or calculate the price.
First we have main.c. This will only contain the function main(). main() will call some of the functions we define in other files. Note that main.c doesn't have a line #include <stdio.h> as it does not use any of the functions in the Standard Device I/O library.
Example 2-4. main.c
#include "display.h" #include "prices.h" int main() { display_options(); calculate_price(); display_price(); return 0; }
Next, we have display.c. This contains two functions, both of which are called from main() and so we put their declarations in a header file display.h.
Example 2-5. display.c
#include <stdio.h> int display_options() { printf("Welcome to the pizza parlor\n"); printf("What size pizza would you like? (in inches)"); return 0; } int display_price() { printf("Your pizza will cost 0.00\n"); return 0; }
Example 2-6. display.h
/* header file just contains function declarations, an file that wants * to use either of these functions just has to #include this file */ int display_options(void); int display_price(void);
Finally, we have prices.c, which contains the functions for getting input from the user and calculating the total cost of the pizza. Only one of these functions is called from main(), the declarations for the other two are therefore put at the top of the file. We'll fill in the code for these functions in Chapter 3.
Example 2-7. prices.c
int get_size(void); int get_toppings(void); int calculate_price() { /* insert code here. Will call get_size() and get_toppings(). */ return 0; } int get_size() { /* insert code here */ return 0; } int get_toppings() { /* insert code here */ return 0; }
Example 2-8. prices.h
int calculate_price(void);
This can then be compiled with the command: gcc -Wall -o pizza_program main.c prices.c display.c. When run, it will display a greeting and announce that your pizza costs "£0.00".
Another New Function
Before.
Primer Summary
What.
Data and Expressions
Really 4-1. bicycles.c
#include <stdio.h> int main() { int number_of_bicycles; int number_of_wheels; number_of_bicycles = 6; number_of_wheels = number_of_bicycles * 2; printf("I have %d bicycles\n", number_of_bicycles); printf("So I have %d wheels\n", number_of_wheels); return 0; }
Bicycle Dissection
There are a few new things to look at here, we'll break the program into chunks to explain them.
int number_of_bicycles; int number_of_wheels;
These two lines each declare a variable. int is one of the built-in data types of the C language. Variables of type int can store positive or negative whole numbers.
number_of_bicycles = 6;
This line stores the value 6 in the variable number_of_bicycles. The equals sign is known as "the assignment operator", it assigns the value on the right hand side of it to the variable on the left hand side.
number_of_wheels = number_of_bicycles * 2;
As always, don't worry if you are unsure about certain parts. We'll do plenty more examples.
Data Types two bytes can store a number between 0 and 65535 (0 and 216. Usually however, integer variables use the first bit to store whether the number is positive or negative so their value will be between -32768 and +32767.. cases where it can be important in this book...
Example 4-2. sizeof_types.c
#include <stdlib.h> int main() { printf("sizeof(char) == %d\n", sizeof(char)); printf("sizeof(short) == %d\n", sizeof(short)); printf("sizeof(int) == %d\n", sizeof(int)); printf("sizeof(long) == %d\n", sizeof(long)); printf("sizeof(long long) == %d\n", sizeof(long long)); return 0; }
Running sizeof_types.c returns the following:
sizeof(char) == 1 sizeof(short) == 2 sizeof(int) == 4 sizeof(long) == 4 sizeof(long long) == 8
Another Example of Assignment
Time for another example. This bit of code demonstrates a few more new things which we'll explain in a minute.
Example handy, first_number is -5 the value of second_number is 30000 the value of third_number is 9901008
The value of third_number.
Table Source was taken from here
Other Print Conversion Specifiers:
Quick Explanation of printf()
You:
Example 4-4. more_printf.c
# include <stdio.h> int main() { int one = 1; int two = 2; int three = 4; /* the values are unimportant here */ printf( "one ==\t%d\ntwo ==\t%d\nthree ==\t%d\n", one, two, three ); return 0; }
Simple Arithmetic
We mentioned at the start of this chapter that point of a program usually involves performing actions on data. By using standard mathematical symbols, arithmetic in C is easily readable.
Example 4-5. wages.c
# include <stdio.h> int main() { int hours_per_day; int days_per_week; hours_per_day = 8; days_per_week = 5; printf("I work %d hours a week.\n", (days_per_week * hours_per_day) ); printf("%d days %d hours \n", days_per_week, hours_per_day); return 0; }
Global Variables
These have there place but are often used to fix badly written code. If two functions need to operate on a variable you should use pointers to share this variable rather than make it available to every function.
Constant Variables
A good rule to follow is to never use numbers other than 1 and 0 in your code. If you require another numeric constant you should make it a const variable; this way it gets a nice meaningful name. The number 40 has little meaning, however, the identifier HOURS_WORKED_PER_WEEK tells us something about what a function is doing. Another benefit is that you can change the value of a const variable in one place rather than having to change all occurrences of 40. Using the latter method it is easy to make a mistake by changing an unrelated occurrence of 40 or forgetting to change an occurrence.
Flow Control
Taking actions based on decisions - C provides two styles of decision making: branching and looping. Branching is deciding what actions to take and looping is deciding how many times to take a certain action.
Branching:
if (expression) statement;
or
if (expression) { statement1; statement2; statement3; }
Here's a quick example:
Example 4-1. using_if.c
#include <stdio.h> int main() { int cows = 6; if (cows > 1) printf("We have cows\n"); if (cows > 10) printf("loads of them!\n"); return 0; }
When compiled and run this program will display:
ciaran@pooh:~/book$ gcc -Wall -Werror -o cows using_if.c ciaran@pooh:~/book$ ./cows We have cows ciaran@pooh:~/book$
The second printf() statement does not get executed because it's expression is false (evaluates to zero).
if ... else
A statement..
Loops
Loops.
To perform a loop, one needs to use the while or for function.
while
The most basic loop in C is the while loop. A while statement is like a repeating if statement. Like an if statement, if the test condition is true the statements get executed. The difference is that after the statements have been executed, the test condition is checked again. If it is still true the statements get executed again. This cycle repeats until the test condition evaluates to false. If the test condition is false the first time, the statements within the while statement will be executed repeatedly until the player guesses the correct number. Note: the while function does not require the line ending ; at the end. The curly brackets indicate that you wish to perform the action within the while function until the conditions are met. To end the while function without allowing for input merely allows input once; if the input is true, then it will not end and since there is no room for input when there is not a variable allotted, then the loop will not read as false.
The similar expression to while is the do .. while function, which is just like a while loop except that the test condition is checked at the end of the loop rather than the start. This has the effect that the content of the loop is always executed at least once.
Example 4; }
for
for is similar to while, it's just written differently. for statements are often used to process lists such a range of numbers:
Example 4-5. for_ten.c
#include <stdio.h> int main() { int i; /* display the numbers from 0 to 9 */ for (i = 0; i < 10; i++) printf("%d\n", i); return 0; }
Will return:
ciaran@pooh:~/book$ gcc for_ten.c ciaran@pooh:~/book$ ./a.out 0 1 2 3 4 5 6 7 8 9 ciaran@pooh:~/book$
Switch
The switch statement is much like a nested if .. else statement. Its mostly a matter of preference which you use; however, switch statement can be slightly more efficient and easier to read.
The Conditional Operator
The ?: operator is just like an if .. else statement except that because it is an operator you can use it within expressions.
Here's an example:
Example 4-6. apples.c
#include <stdio.h> int main() { int apples = 6; printf("I have %d apple%s\n", apples, (apples == 1) ? "" : "s"); return 0; }
?: is a ternary operator in that it takes three values, this is the only ternary operator C has.
Break & Continue
You've see break already, we ended each case of our switch statement with one. break exits out of a loop.
continue is similar to break in that it short circuits the execution of a code block but continue brings execution back to the start of a loop.
Pointers
The Basics output shows you the address of the two variables, the addresses your system assigns to the variables will be different to mine. In printf() you'll notice we used %p to display the addresses. This is the conversion specifier for all pointers. Anyway, here's the output I got:
There. That's not too complicated. Once you are comfortable with pointers you're well on your way to mastering C.
The Address of a Variable
When.
Pointers as Function Arguments
One of the best things about pointers is that they allow functions to alter variables outside of there own scope. By passing a pointer to a function you can allow that function to read and write to the data stored in that variable. Say you want to write a function that swaps the values of two variables. Without pointers this would be practically impossible, here's how you do it with pointers:
Example 5-2. swap_ints.c
#include <stdio.h> int swap_ints(int *first_number, int *second_number); int main() { int a = 4, b = 7; printf("pre-swap values are: a == %d, b == %d\n", a, b) swap_ints(&a, &b); printf("post-swap values are: a == %d, b == %d\n", a, b) return 0; } int swap_ints(int *first_number, int *second_number) { int temp; /* temp = "what is pointed to by" first_number; etc... */ temp = *first_number; *first_number = *second_number; *second_number = temp; return 0; }
As you can see, the function declaration of swap_ints() tells GCC to expect two pointers (address of variables). Also, the address-of operator (&) is used to pass the address of the two variables rather than their values. swap_ints() then reads
Pointer Arithmetic
Arithmetic.
Generic Pointers
When:
Example 5-3. generic_pointer.c
int main() { int i; char c; void *the_data; i = 6; c = 'a'; the_data = &i; printf("the_data points to the integer value %d\n", *(int*) the_data); the_data = &c; printf("the_data now points to the character %c\n", *(char*) the_data); return 0; }
Structured Data Types
Contiguous and structured data
What is Structured data?
C provides two methods for defining structured or aggregate data types: arrays and structs. Both can contain any of the standard data types, including pointers and other structs and arrays. Arrays contain many variables of the same type while structs can contain any mixture of types.
Arrays.
Declaring and Accessing Arrays
Declaring an array is much the same as declaring any other variable except that you must specify the array size. The size (or number of elements) is an integer value placed in square brackets after the arrays identifier.
Example 6-1. first_arrays.c
#include <stdio.
Initializing Arrays
In the above example we initialized the array hourly_wage by placing a comma separated list of values in curly braces. Using this method you can initialize as few or as many array elements as you like however you cannot initialize an element without initializing all the previous elements. If you initialize some but not all elements of an array the remaining elements will be automatically initialized to zero.
To get around this inconvenience, a GNU extension to the C language allows you to initialize array elements selectively by number. When initialized by number, the elements can be placed in any order withing the curly braces preceded by [index]=value. Like so:
Example 6-2. initialize; }
Multidimensional Arrays
The array we used in the last example was a one dimensional array. Arrays can have more than one dimension, these arrays-of-arrays are called multidimensional arrays. They are very similar to standard arrays with the exception that they have multiple sets of square brackets after the array identifier. A two dimensional array can be though of as a grid of rows and columns.
Example 6-3. number_square.c
#include <stdio.h> const int num_rows = 7; const int num_columns = 5; int main() { int box[num_rows][num_columns]; int row, column; for(row = 0; row < num_rows; row++) for(column = 0; column < num_columns; column++) box[row][column] = column + (row * num_columns); for(row = 0; row < num_rows; row++) { for(column = 0; column < num_columns; column++) { printf("%4d", box[row][column]); } printf("\n"); } return 0; }
If you compile and run this example you'll get a box of numbers like this:
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
The above array has two dimensions and can be called a doubly subscripted array. GCC allows arrays of up to 29 dimensions although actually using an array of more than three dimensions is very rare.
Arrays of Characters (Text)
Text in C is represented by a number of consecutive variables of type char terminated with the null character '\0'
Defining Data Types
The C language provides only the most basic, commonly used types, many languages provide a larger set of types but this is only for convenience. C's way of handling text strings is a good example of this. At times you may think it would be handy if there were other data types which could store complex data. C allows you to define your own.
Structured Data
In C you can create a new type e.g. Person. Person can store an int called age, a string called name and another int called height_in_cm. Here's the code to make this new type:
struct Person { char *name; int age; int height_in_cm; };
#include <stdio.h> struct Person { char *name; int age; int height_in_cm; } int main() { struct Person hero = {"Robin Hood", 20, 191}; struct Person john; john.age = 31; john.name = "John Little"; john.height_in_cm = 237; printf("%s is %d years old and stands %dcm tall in his socks.\n", john.name, john.age, john.height_in_cm); printf( "He is often seen with %s.\n", hero.name ); return 0; }
When compiled and executed this will display:
John Little is 31 years old and stands 237cm tall in his socks. He is often seen with Robin Hood.
Unions
C.
Run-Time Memory Allocation
Run-time memory allocation refers to requesting memory at run-time.
Why Do You Need This?
Often, when you write a program, you don't actually know how much data you will have to store or process. In previous examples, we've read in some text from the user and we've used large character arrays to store this data. But what happens if the user enters more text than we can handle? Your program crashes. Disaster. However, at run-time, an application can make a request for more memory.
Dynamic Memory Functions
glibc provides functions for requesting extra memory. malloc() is the first function we will show you. You must have a pointer to start with.
Run-Time Memory Summary
Forgetting to free memory (using the free() function) when you are finished with it is one of the worst programming mistakes you can make. Is losing pointers a common problem? pointer falls out of scope?
Strings and File I/O
Input/Output in C
Like many other programming languages, C programs read in (input) or write out (output) characters. Of note is that most any underlying computer (executing C code) also generally has a mechanism by which a single character may be input or output. This input or output of a single character will often be the only way for a program to accomplish I/O functionality.
The typical way that I/O is accomplished for a C program is to use a standard (always provided) library of I/O functions. The example C program given used the printf function to print out a string (a bunch of characters). To include the standard I/O library, the line
#include <stdio.h>
appears at the top of the C source code.
These notes are a guide to a very few of the standard I/O functions. Much more complete information is available in the Kernighan and Ritchie book. stdin and stdout
The C language (the Unix operating system, really) has a notion of input coming from a place known as standard input. It is written as stdin. By default, standard input comes from the keyboard.
And, output goes to a place known as standard output. It is written as stdout. By default, standard output goes to the screen.
getchar() and putchar() and also getc() and putc()
The function getchar() retrieves a single character from standard input. Its signature appears as
int getchar(void)
This function's return value will be:
1. the next input character or 2. the constant value EOF at the end of file
The function putchar() sends a single character to standard output. Its signature appears as
int putchar(int)
The character to be output is passed as a parameter. The return value of the function will be:
1. the character output
or
2. the constant value EOF if an error occurred
These two I/O functions are rather similar to the I/O available with our 354 MIPS simulator. It has a standard way to get a single character (from standard input) or output a single character (to standard output).
The functions getc() and putc() are much the same. The difference between these and getchar() and putchar() are an extra parameter that identifies a file (through the use of a file descriptor or file pointer) for input to come from, or output to go to. The structure FILE defined in <stdio.h> gives access to file pointers and files.
NOTE: The simulator used for 354 adds extensions to the assembly language, such that there appears to be new MIPS assembly language instructions that do input and output. This makes it ever so much easier for the assembly language programmer to write code that does I/O. As the simulator (a program) was originally written in C, these I/O pseudoinstructions mimic getc() and putc(), and even have the mnemonics getc and putc. scanf() and printf()
printf() is a function that "converts, formats, and prints it arguments on the standard output. . .". It is similar to Java's System.out.print method. It takes a variable number of arguments, so its signature appears as
int printf(char *format, argument1, argument2, ... )
The integer returned by this function is the number of characters printed. The first argument is a string, which describes the formatting of what is printed. This string contains 2 types of items: characters to be copied onto the output (very much like in Java), and specifications of placement and how the arguments are to be formatted. Each of these specifications (which require a further argument within the list of arguments), is a set of characters that is identified by the percent character (%). The percent character may be followed by a modifier (see the list on page 153, section 7.2 in Kernighan and Ritchie), and is ended by what is known as a conversion character. Examples are
1. d to print the next argument within the argument list as a decimal number.
2. c to print the next argument within the argument list as a character.
3. x to print the next argument within the argument list as a hexadecimal number.
4. s to print the next argument within the argument list as a null-terminated string.
An (optional) modifier specifies things such as maximums and minimums for number of characters to be printed, and number of digits of precision for floating point values. A quick code example:
x = 25; y = 1; printf("The value of x is %d, and the value of y is %d.\n", x, y);
The output (to standard output) will appear as
The value of x is 25, and the value of y is 1.
Further output will start at the beginning of the next line, due to the newline character (\n).
Here is a short example, to help with the spacing and number of characters that get printed when using a modifier. This not a program, as what the output looks like has been written in to the right of the line that would generate that particular output.
#include <stdio.h> main() { int x; OUTPUT x = 354; printf("[%d]\n", x); [354] printf("[%1d]\n", x); [354] printf("[%2d]\n", x); [354] printf("[%3d]\n", x); [354] printf("[%4d]\n", x); [ 354] printf("[%-4d]\n", x); [354 ] }
scanf() is similar to printf, but it reads input. The first argument will be a format string, which specifies the expected form of the input. Further arguments are pointers to variables. According to the format string, variable values are assigned as encountered. They must be pointers. Like printf, it takes a variable number of arguments, so its signature appears as
int scanf(char *format, addr of argument1, addr of argument2, ... )
scanf returns the number of successfully matched and assigned input items. Here is a quick code fragment example:
if ( scanf("%d %d\n", &x, &y) != 2 ) { printf("bad input\n"); }
If the input typed appeared as
-3 6
then in this code fragment, scanf returns the value 2, and the value of variable x will be -3, and the value of variable y will be 6.
Reference: Miller, Karen. " Input/Output in C." CS/ECE 354: Machine Organization and Programming. 2008. University of Wisconsin. 12 Feb 2008 <>.
Storage Classes
9.1. What are Storage Classes?
You will have noticed that variables in functions lose their values every time the function exists, this is done for reasons of efficiency, the operating system doesn't know if you will need the data again so it releases the memory allocated to your program back to the system.
9.2. Auto
By.
9.3. Static
Static variables are variables that don't get deleted when they fall out of scope, they are permanent and retain their value between calls to the function. Here's an example:
Example 9-1. list_squares.c
#include <stdio.h> int get_next_square(void); int main() { int i; for(i = 0; i < 10; i++) printf("%6d\n", get_next_square()); printf("and %6d\n", get_next_square()); return 0; } int get_next_square() { static int count = 1; count += 1; return count * count; }
This will list the squares of the numbers from zero to ten. Zero to nine are printed by the loop and the square of ten is printed afterwards just to show it still has it's value.
9.4. Extern
When.
9.5. Register
The register storage class is used as a hint to the compiler that a variable is heavily used and access to it should be optimised if possible. Variables are usually stored in normal memory (RAM) and passed back and forth to the computers processor as needed, the speed the data is sent at is pretty fast but can be improved on. Almost all computer processors contain cpu registers, these are memory slots on the actual processor, storing data there gets rid of the overhead of retrieving the data from normal memory. This memory is quite small compared to normal memory though so only a few variables can be stored there. GCC will always make use of registers by deciding what variables it thinks will be accessed often, this works well but will never be perfect because GCC doesn't know the purpose of your program. By using the register keyword you can tell GCC what needs to be optimised.
One problem with placing a variable into a cpu register is that you can't get a pointer to it, pointers can only point to normal memory. Because of this restriction GCC will ignore the register keyword on variables whos address is taken at any point in the program.
The resulting program will contain a request, on creation of the variable that it be placed in a cpu register, the operating system may ignore or honor this request.
9.6. The Restrict Type Qualifier
This is something to do with pointers, I think it tells the compiler that a specific pointer is the only pointer to a section of memory, the compiler can optimize code better with this knowledge. I think.
9.7. typedef
typedef isn't much like the others, it's used to give a variable type a new name. There are two main reasons for doing this. The most common is to give a name to a struct you have defined so that you can use your new data type without having to always precede it with the struct keyword.
The second use for typedef is for compatibility. Say you want to store a 32-bit number. If you use int you are not guaranteed that it will be 32-bit on every machine. To get around this you can use preprocessor directives to selectively typedef a new type to the right size.
Example 9-2. battleships.c
#include <stdio.h> /* type, position coordinates and armament */ struct _ship { int type; int x; int y; int missiles; }; typedef struct _ship ship; int main() { ship battle_ship_1; ship battle_ship_2 = {1, 60, 66, 8}; battle_ship_1.type = 63; battle_ship_1.x = 54; battle_ship_1.y = 98; battle_ship_1.missiles = 12; /* More code to actually use this data would go here */ return 0; }
The C Preprocessor
When & how to use them
What is the C Preprocessor.
What is it used for?
Macros are snippets of code that get processed before compilation. This is done by the C preprocessor, #define statements are macros. Take a look at this piece of code:
Example 11-1. box_of_stars.c
#define SIZE_OF_SQUARE 4 int main() { int i, j; for(i = 0; i < SIZE_OF_SQUARE; i++) { for(j = 0; j < SIZE_OF_SQUARE; j++) { printf("*"); // print an asterisk for each column } printf("\n"); // and a newline at the end of each row } }
The output of this code will be a box:
**** **** **** ****
The C preprocessor simply replaces the macro SIZE_OF_BOX with the value "4". This very useful for two reasons:
Firstly the size of the box can be changed by just editing one line. This isn't a huge advantage in the above example as there are just two uses of SIZE_OF_BOX but in larger programs this make life much easier and removes the possibility of forgetting to change one of the values.
Secondly it makes the code more readable, meaningful names can be given to values such as
#define PI 3.142857143.
Some Sample Macros
Some of the small function in glibc are implemented as macros, getc() is one
Caveats for Macros
Macros can be miss-used and it's hard to catch the bugs because the macro no longer exists when the code gets to the compiler. The most error is the macro argument with side effect. Take the this small example:
Example 11-2. max_macro.c
#define MAX(a, b) (a > b ? a : b) int main() { int cows = 10, sheep = 12; printf("we have %d of our most common animal\n", MAX(cows, sheep)); return 0; }
We compile and execute this code and; }
Can you see what's going to happen?.
Are Macros Necessary?
The preprocessor was commonly used to make up for small deficiencies of the language, however, as the language has evolved these defiances have be all but done away. It's still good to know how to use and understand preprocessor macros, they are very common. Macros have been part of the language for longer than their replacements and people have gotten used to them.
Replacing Simple Macros
If.
Replacing Complex Macros
Complex macros, that is functions implemented as macros, can be replaced by inline functions.
Variable Length Arguments
The VA_ARGS macros etc.
What are Variable Length Arguments?
Variable length argument lists are something you have already come across. Think of printf(), how would you write the prototype for this function when you don't know how many arguments will be passed to it?
Variable Length Argument Tutorialon Cprogramming.com has a write up on variable length arguments.
Tricks with Functions.
Pointers to Functions.
What are Virtual Functions?
Another use of the void data type is for making pointers to functions. This is a fairly advanced programming technique but a very useful one once you become comfortable with it.
Here is an example of a function pointer:
Example 12-1. virtual_function.c
int main() { /* oh, crap, better go write one... */ return 0; }
Nesting Functions
GCC permits functions to be defined within other functions. Functions defined like this are known as nested functions and obey the same scoping rules as variables. When the parent function exits, the child function falls out of scope and is unavailable.
The benefits of nested functions
Probably?
Declaring and Defining Nested Variables.
Example 12-2. Simple Nested Function
#include <stdio.h> int main() { int swap (int *a, int *b) { int c; c = *a; *a = *b; *b = c; return 0; } int first = 12, second = 34; printf("f is %d and s is %d\n", first, second); swap(&first, &second); printf("f is %d and s is %d\n", first, second); return 0; }
You don't have to declare nested functions like you do normal functions however you can if you like. The only reason for doing so would be for the sake of readability, you might like the function definition to appear near where it is used. It's up to you, but if you do decide to declare you nested function you must explicitly declare it as auto.
Scope
Nested functions have local scope, declaring a nested function as extern will cause an error. static and inline are both valid.
Taking Command Line Arguments
How does C Handle Command Line Arguments?
A program starts by the operating system calling a programs main() function. Every one of your programs so far have defined main() as a function taking no arguments but this is not always the case. main() is the only function in C that can be defined in multiple ways. It can take no arguments, two arguments or three arguments. The two and three argument forms allow it to receive arguments from the shell. The three argument form is not particularly useful and is never necessary, we'll cover it briefly at the end of this chapter.
The two argument form takes an int and an array of strings. When defining main() you can give these arguments any name but it is convention to call them argc and argv[]. The first argument holds a count of how many elements there are in the array of strings passed as the second argument. The array is always null terminated so argv[argc] == NULL.
Here's a short program demonstrating the use of
Example 13-1. list_args.c
int main(int argc, char *argv[]) { int i; for(i = 0; i < argc; i++) printf("argv[%d] == %s\n", i, argv[i]); return 0; }
to be passed to main() via two arguments: an int and a *char[] (an array of strings). The int is usually called argc which is short for "argument count", as the name suggests, it stores the number of arguments passed to main(). The second argument, usually called argv is an array of strings.
Argp
C's method of getting command line arguments is pretty simple but when your program has a lot of options it can get complex. To solve this, Glibc provides a series of functions to perform command tasks for you. The "argp_*" functions perform much of the work for you and they do it in a standard way which makes you program more familiar to users. Here's an short program using argp:
Example 13-2. simple_argp.c
/* put a tiny argp program here */
When you run this program you will see...
Using More of the Argp Functionality
Here's a longer program, it uses four global variables to store information about your program:
Example 13-3. better_argp.c
#include <stdlib.h> #include <argp.h> const char *argp_program_version = "simple_argp 0.1"; const char *argp_program_bug_address = "<some_email_address@you_care_about.com>"; static char doc[] = "short program to show the use of argp\nThis program does little"; static char args_doc[] = "ARG1 ARG2"; /* initialise an argp_option struct with the options we except */ static struct argp_option options[] = { {"verbose", 'v', 0, 0, "Produce verbose output" }, {"output", 'o', "FILE", 0, "Output to FILE" }, { 0 } }; /* Used by `main' to communicate with `parse_opt'. */ struct arguments { char *args[2]; /* ARG1 & ARG2 */ int silent, verbose; char *output_file; }; /* Parse a single option. */ static error_t parse_opt (int key, char *arg, struct argp_state *state) { /* Get the INPUT argument from `argp_parse', which we know is a pointer to our arguments structure. */ struct arguments *arguments = state->input; switch (key) { case 'q': case 's': arguments->silent = 1; break; case 'v': arguments->verbose = 1; break; case 'o': arguments->output_file = arg; break; case ARGP_KEY_ARG: if (state->arg_num >= 2) /* Too many arguments. */ argp_usage (state); arguments->args[state->arg_num] = arg; break; case ARGP_KEY_END: if (state->arg_num < 2) /* Not enough arguments. */ argp_usage (state); break; default: return ARGP_ERR_UNKNOWN; } return 0; } /* Our argp parser. */ static struct argp argp = { options, parse_opt, args_doc, doc }; int main (int argc, char **argv) { struct arguments arguments; /* Default values. */ arguments.silent = 0; arguments.verbose = 0; arguments.output_file = "-"; /* Parse our arguments; every option seen by `parse_opt' will be reflected in `arguments'. */ argp_parse (&argp, argc, argv, 0, 0, &arguments); printf ("ARG1 = %s\nARG2 = %s\nOUTPUT_FILE = %s\n" "VERBOSE = %s\nSILENT = %s\n", arguments.args[0], arguments.args[1], arguments.output_file, arguments.verbose ? "yes" : "no", arguments.silent ? "yes" : "no"); exit (0); }
This is pretty simple. no?
Environment Variables
BLAH, talk about how to use the three argument form and the other way of getting at environment variables, show a toy example.
Using and Writing Libraries
What are Libraries?
Libraries are files that contain several functions, much like the ones you create when writing your own programs. The functions in libraries can be used in other applications by linking the application to the library. There are two kinds of libraries that you can use and create on Unix systems: static libraries and shared (or dynamic) libraries.
Static libraries are collections of object files that are linked into the program during the linking phase of compilation.
Shared (or dynamic) libraries are linked into the program in two steps. The first phase occurs during compilation. In this step, the linker verifies that all the symbols (functions, variables, etc.) required by the program, are either linked into the program, or in one of its shared libraries. The object files within the dynamic library are not inserted into the executable file. Instead, when the program is started, a dynamic loader checks to see which shared libraries were linked with the program, loads them to memory, and attaches them to the copy of the program in memory.
Writing a library
Writing a library is similar to writing a program. The first obvious difference is that there is no main(). Libraries are very handy for functions you use regularly or functions you think others may find useful.
To make your own library, you must first compile each of your sources into an object.
gcc -c multiplication.c -o multiplication.o gcc -c division.c -o division.o
Stages of Compilation
The three main stages in compiling a program are preprocessing, compilation and linking. In C code, lines that begin with the hash symbol "#" are commands for the preprocessor, GCC includes a preprocessor called CPP (C Preprocessor). #define and #include are by far the most common preprocessor commands The compilation process is broken down into many smaller stages. One of these stages is called compilation. Compilation is the process of converting source code to object code. You do this by invoking GCC with "-c". When programs become large it can take time to compile them, by splitting a program into smaller files you can re-compile only the files that you have changed. First you must tell gcc to only compile the source files.
The main tool used to create static libraries is a program called 'ar', which means 'archiver'. In addition to creating these static libraries (which are archive files), this program can be used to modify object files in the static library, list the names of object files in the library, etc. You use the 'ar' command to create a static library and put the objects in it. The following command does this.
ar rvs mathstuff.a multiplication.o division.o
Each letter in 'rvs' means something. The 'r' flag tells 'ar' to replace object files in the library with new ones. Since there are no object files in this library, this essentially means add them to the library. The next time you run the command, it will replace the old version with the new version. Other options are to extract and delete objects in the library. The 'v' in 'rvs' means verbose, which tells 'ar' to keep you informed about what it is doing. The 's' flag tells 'ar' to create a symbol table, which is an additional element that gcc needs when using a library. 'ar' can be used to make libraries of anything - text, images, sounds, etc. When using 'ar' to make libraries of objects, however, use the 's' flag.
Using libraries
To use the library, add the name of the library to the list of object file names given to the linker, using a special flag. For example:
gcc main.c mathstuff.a -o main.exe
The order in which you list the libraries is very important. In the process of scanning the command line, gcc pulls in what it needs at that point. Each time it sees an object, it adds it to the program. Whenever it sees a library, it pulls in only the objects that it needs then. Libraries should always be listed after the objects.
If you are building a system library (like the C library, libc.a), you need to carry out three steps: give the library a special name, put it in a special place, and use a special option for it.
1. The name of your library must start with lib,e.g. libc.a or libstuff.a. The 'lib' prefix is a convention that identifies your file as a system library.
2. Your library must be moved into djgpp's lib directory. For example, lib/libc.a and lib/libm.a are in there. gcc looks in djgpp's lib directory for system libraries.
3. When linking your program, you use the -l flag to specify only the middle part of your library. For example, if your library is libstuff.a you would use gcc -lstuff to link your library (you must list -lstuff after the objects). The '-l' flag tells the linker where to look.
Speed
Easy optimisations: Low hanging fruit
C is well know as the fastest high-level language available
About Optim.
What are Function Attributes?
Function attributes are a GNU extension to the C language. They allow you to give GCC more information about a function. This information can be used for many purposes including optimisation and stricter checking.
Function Attribute Syntax
Function attributes are specified as part of a function declaration. After the closing parenthesis of the functions arguments the keyword __attribute__ followed by the desired attributes in a set of double parenthesis. Here's a function with the pure attribute.
int my_func(int first, int second) __attribute__ ((pure));
Functions can have multiple attributes, to do this, separate the attributes with commas inside the double parenthesis.
What are pure and const?
A.
Appendix A. GNU Free Documentation License
Version 1.2, November 2002.
OBFUSCATED CODE
Obfuscated code is source code or intermediate language in terms of computer programming that is very hard to read and understand, often intentionally. Some languages are more prone to obfuscation than others.[1][2] C,[3] C++[4] and Perl[5] are most often cited as easily obfuscatable languages. Macro preprocessors are often used to create hard-to-read code by masking the standard language syntax and grammar from the main body of code. The term shrouded code has also been used.
Obfuscators may be used to compact object code or interpreted code without affecting its behaviour when size is important. Common cases include MIDlets – in which the meaningful identifiers embedded in the Java class files are replaced with shorter ones – and Javascript code on the web. Code is sometimes obfuscated deliberately for recreational purposes. There are programming contests which reward the most creatively obfuscated code: the International Obfuscated C Code Contest, Obfuscated Perl Contest, International Obfuscated Ruby Code Contest, and Obfuscated PostScript Contest.
An example of C obfuscated code that will print out the verses of the song "12 Days of Christmas":
);}
This information on obfuscated code was taken from here.
This website writes code in the following way to print out Hello World:
main(){int i)))}; for(i=(1>>1);i <(((1<<1) <<(1<<1))+((1 <<1)<< (1<<(1>>1 ))) + (1<<1)); i++) printf("%c",n[i]); }
Here is an example of obfuscated code that prints out about 3000 digits of the 'e' value. The code is written in the shape of 'Pi': Taken from here. This website also contains more examples of obfuscated code.
char _3141592654[3141 ],__3141[3141];_314159[31415],_3141[31415];main(){register char* _3_141,*_3_1415, *_3__1415; register int _314,_31415,__31415,*_31, _3_14159,__3_1415;*_3141592654=__31415=2,_3141592654[0][_3141592654 -1]=1[__3141]=5;__3_1415=1;do{_3_14159=_314=0,__31415++;for( _31415 =0;_31415<(3,14-4)*__31415;_31415++)_31415[_3141]=_314159[_31415]= - 1;_3141[*_314159=_3_14159]=_314;_3_141=_3141592654+__3_1415;_3_1415= __3_1415 +__3141;for (_31415 = 3141- __3_1415 ; _31415;_31415-- ,_3_141 ++, _3_1415++){_314 +=_314<<2 ; _314<<=1;_314+= *_3_1415;_31 =_314159+_314; if(!(*_31+1) )* _31 =_314 / __31415,_314 [_3141]=_314 % __31415 ;* ( _3__1415=_3_141 )+= *_3_1415 = *_31;while(* _3__1415 >= 31415/3141 ) * _3__1415+= - 10,(*--_3__1415 )++;_314=_314 [_3141]; if ( ! _3_14159 && * _3_1415)_3_14159 =1,__3_1415 = 3141-_31415;}if( _314+(__31415 >>1)>=__31415 ) while ( ++ * _3_141==3141/314 )*_3_141--=0 ;}while(_3_14159 ) ; { char * __3_14= "3.1415"; write((3,1), (--*__3_14,__3_14 ),(_3_14159 ++,++_3_14159))+ 3.1415926; } for ( _31415 = 1; _31415<3141- 1;_31415++)write( 31415% 314-( 3,14),_3141592654[ _31415 ] + "0123456789","314" [ 3]+1)-_314; puts((*_3141592654=0 ,_3141592654)) ;_314= *"3.141592";}
You can find more examples of obfuscated code here. | http://wiki.roboteducation.org/Learning_GNU_C | crawl-002 | refinedweb | 10,436 | 64.91 |
.17 anton 47: @sp 3 48: @center This manual is under construction 1.1 anton 49: 50: @comment The following two commands start the copyright page. 51: @page 52: @vskip 0pt plus 1filll 1.21 anton 53: Copyright @copyright{} 1995 Free Software Foundation, Inc. 1.1 anton 54: 55: @comment !! Published by ... or You can get a copy of this manual ... 56: also that the 63: sections entitled "Distribution" and "General Public License" are 64: included exactly as in the original, and provided that the entire 65: resulting derived work is distributed under the terms of a permission 66: notice identical to this one. 67: 68: Permission is granted to copy and distribute translations of this manual 69: into another language, under the above conditions for modified versions, 70: except that the sections entitled "Distribution" and "General Public 71: License" may be included in a translation approved by the author instead 72: of in the original English. 73: @end titlepage 74: 75: 76: @node Top, License, (dir), (dir) 77: @ifinfo 1.17 anton 78: Gforth is a free implementation of ANS Forth available on many 1.21 anton 79: personal machines. This manual corresponds to version 0.1. 1.1 anton 80: @end ifinfo 81: 82: @menu 1.4 anton 83: * License:: 1.17 anton 84: * Goals:: About the Gforth Project 1.4 anton 85: * Other Books:: Things you might want to read 1.17 anton 86: * Invocation:: Starting Gforth 87: * Words:: Forth words available in Gforth 1.4 anton 88: * ANS conformance:: Implementation-defined options etc. 1.17 anton 89: * Model:: The abstract machine of Gforth 90: * Emacs and Gforth:: The Gforth Mode 1.4 anton 91: * Internals:: Implementation details 92: * Bugs:: How to report them 1.17 anton 93: * Pedigree:: Ancestors of Gforth 1.4 anton 94: * Word Index:: An item for each Forth word 95: * Node Index:: An item for each node 1.1 anton 96: @end menu 97: 98: @node License, Goals, Top, Top 1.20 pazsan 99: @unnumbered GNU GENERAL PUBLIC LICENSE 100: @center Version 2, June 1991 101: 102: @display 103: Copyright @copyright{} 1989, 1991 Free Software Foundation, Inc. 104: 675 Mass Ave, Cambridge, MA 02139, USA 105: 106: Everyone is permitted to copy and distribute verbatim copies 107: of this license document, but changing it is not allowed. 108: @end display 109: 110: @unnumberedsec Preamble 111: 112: The licenses for most software are designed to take away your 113: freedom to share and change it. By contrast, the GNU General Public 114: License is intended to guarantee your freedom to share and change free 115: software---to make sure the software is free for all its users. This 116: General Public License applies to most of the Free Software 117: Foundation's software and to any other program whose authors commit to 118: using it. (Some other Free Software Foundation software is covered by 119: the GNU Library General Public License instead.) You can apply it to 120: your programs, too. 121: 122: When we speak of free software, we are referring to freedom, not 123: price. Our General Public Licenses are designed to make sure that you 124: have the freedom to distribute copies of free software (and charge for 125: this service if you wish), that you receive source code or can get it 126: if you want it, that you can change the software or use pieces of it 127: in new free programs; and that you know you can do these things. 128: 129: To protect your rights, we need to make restrictions that forbid 130: anyone to deny you these rights or to ask you to surrender the rights. 131: These restrictions translate to certain responsibilities for you if you 132: distribute copies of the software, or if you modify it. 133: 134: For example, if you distribute copies of such a program, whether 135: gratis or for a fee, you must give the recipients all the rights that 136: you have. You must make sure that they, too, receive or can get the 137: source code. And you must show them these terms so they know their 138: rights. 139: 140: We protect your rights with two steps: (1) copyright the software, and 141: (2) offer you this license which gives you legal permission to copy, 142: distribute and/or modify the software. 143: 144: Also, for each author's protection and ours, we want to make certain 145: that everyone understands that there is no warranty for this free 146: software. If the software is modified by someone else and passed on, we 147: want its recipients to know that what they have is not the original, so 148: that any problems introduced by others will not reflect on the original 149: authors' reputations. 150: 151: Finally, any free program is threatened constantly by software 152: patents. We wish to avoid the danger that redistributors of a free 153: program will individually obtain patent licenses, in effect making the 154: program proprietary. To prevent this, we have made it clear that any 155: patent must be licensed for everyone's free use or not licensed at all. 156: 157: The precise terms and conditions for copying, distribution and 158: modification follow. 159: 160: @iftex 161: @unnumberedsec TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 162: @end iftex 163: @ifinfo 164: @center TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 165: @end ifinfo 166: 167: @enumerate 0 168: @item 169: This License applies to any program or other work which contains 170: a notice placed by the copyright holder saying it may be distributed 171: under the terms of this General Public License. The ``Program'', below, 172: refers to any such program or work, and a ``work based on the Program'' 173: means either the Program or any derivative work under copyright law: 174: that is to say, a work containing the Program or a portion of it, 175: either verbatim or with modifications and/or translated into another 176: language. (Hereinafter, translation is included without limitation in 177: the term ``modification''.) Each licensee is addressed as ``you''. 178: 179: Activities other than copying, distribution and modification are not 180: covered by this License; they are outside its scope. The act of 181: running the Program is not restricted, and the output from the Program 182: is covered only if its contents constitute a work based on the 183: Program (independent of having been made by running the Program). 184: Whether that is true depends on what the Program does. 185: 186: @item 187: You may copy and distribute verbatim copies of the Program's 188: source code as you receive it, in any medium, provided that you 189: conspicuously and appropriately publish on each copy an appropriate 190: copyright notice and disclaimer of warranty; keep intact all the 191: notices that refer to this License and to the absence of any warranty; 192: and give any other recipients of the Program a copy of this License 193: along with the Program. 194: 195: You may charge a fee for the physical act of transferring a copy, and 196: you may at your option offer warranty protection in exchange for a fee. 197: 198: @item 199: You may modify your copy or copies of the Program or any portion 200: of it, thus forming a work based on the Program, and copy and 201: distribute such modifications or work under the terms of Section 1 202: above, provided that you also meet all of these conditions: 203: 204: @enumerate a 205: @item 206: You must cause the modified files to carry prominent notices 207: stating that you changed the files and the date of any change. 208: 209: @item 210: You must cause any work that you distribute or publish, that in 211: whole or in part contains or is derived from the Program or any 212: part thereof, to be licensed as a whole at no charge to all third 213: parties under the terms of this License. 214: 215: @item 216: If the modified program normally reads commands interactively 217: when run, you must cause it, when started running for such 218: interactive use in the most ordinary way, to print or display an 219: announcement including an appropriate copyright notice and a 220: notice that there is no warranty (or else, saying that you provide 221: a warranty) and that users may redistribute the program under 222: these conditions, and telling the user how to view a copy of this 223: License. (Exception: if the Program itself is interactive but 224: does not normally print such an announcement, your work based on 225: the Program is not required to print an announcement.) 226: @end enumerate 227: 228: These requirements apply to the modified work as a whole. If 229: identifiable sections of that work are not derived from the Program, 230: and can be reasonably considered independent and separate works in 231: themselves, then this License, and its terms, do not apply to those 232: sections when you distribute them as separate works. But when you 233: distribute the same sections as part of a whole which is a work based 234: on the Program, the distribution of the whole must be on the terms of 235: this License, whose permissions for other licensees extend to the 236: entire whole, and thus to each and every part regardless of who wrote it. 237: 238: Thus, it is not the intent of this section to claim rights or contest 239: your rights to work written entirely by you; rather, the intent is to 240: exercise the right to control the distribution of derivative or 241: collective works based on the Program. 242: 243: In addition, mere aggregation of another work not based on the Program 244: with the Program (or with a work based on the Program) on a volume of 245: a storage or distribution medium does not bring the other work under 246: the scope of this License. 247: 248: @item 249: You may copy and distribute the Program (or a work based on it, 250: under Section 2) in object code or executable form under the terms of 251: Sections 1 and 2 above provided that you also do one of the following: 252: 253: @enumerate a 254: @item 255: Accompany it with the complete corresponding machine-readable 256: source code, which must be distributed under the terms of Sections 257: 1 and 2 above on a medium customarily used for software interchange; or, 258: 259: @item 260: Accompany it with a written offer, valid for at least three 261: years, to give any third party, for a charge no more than your 262: cost of physically performing source distribution, a complete 263: machine-readable copy of the corresponding source code, to be 264: distributed under the terms of Sections 1 and 2 above on a medium 265: customarily used for software interchange; or, 266: 267: @item 268: Accompany it with the information you received as to the offer 269: to distribute corresponding source code. (This alternative is 270: allowed only for noncommercial distribution and only if you 271: received the program in object code or executable form with such 272: an offer, in accord with Subsection b above.) 273: @end enumerate 274: 275: The source code for a work means the preferred form of the work for 276: making modifications to it. For an executable work, complete source 277: code means all the source code for all modules it contains, plus any 278: associated interface definition files, plus the scripts used to 279: control compilation and installation of the executable. However, as a 280: special exception, the source code distributed need not include 281: anything that is normally distributed (in either source or binary 282: form) with the major components (compiler, kernel, and so on) of the 283: operating system on which the executable runs, unless that component 284: itself accompanies the executable. 285: 286: If distribution of executable or object code is made by offering 287: access to copy from a designated place, then offering equivalent 288: access to copy the source code from the same place counts as 289: distribution of the source code, even though third parties are not 290: compelled to copy the source along with the object code. 291: 292: @item 293: You may not copy, modify, sublicense, or distribute the Program 294: except as expressly provided under this License. Any attempt 295: otherwise to copy, modify, sublicense or distribute the Program is 296: void, and will automatically terminate your rights under this License. 297: However, parties who have received copies, or rights, from you under 298: this License will not have their licenses terminated so long as such 299: parties remain in full compliance. 300: 301: @item 302: You are not required to accept this License, since you have not 303: signed it. However, nothing else grants you permission to modify or 304: distribute the Program or its derivative works. These actions are 305: prohibited by law if you do not accept this License. Therefore, by 306: modifying or distributing the Program (or any work based on the 307: Program), you indicate your acceptance of this License to do so, and 308: all its terms and conditions for copying, distributing or modifying 309: the Program or works based on it. 310: 311: @item 312: Each time you redistribute the Program (or any work based on the 313: Program), the recipient automatically receives a license from the 314: original licensor to copy, distribute or modify the Program subject to 315: these terms and conditions. You may not impose any further 316: restrictions on the recipients' exercise of the rights granted herein. 317: You are not responsible for enforcing compliance by third parties to 318: this License. 319: 320: @item 321: If, as a consequence of a court judgment or allegation of patent 322: infringement or for any other reason (not limited to patent issues), 323: conditions are imposed on you (whether by court order, agreement or 324: otherwise) that contradict the conditions of this License, they do not 325: excuse you from the conditions of this License. If you cannot 326: distribute so as to satisfy simultaneously your obligations under this 327: License and any other pertinent obligations, then as a consequence you 328: may not distribute the Program at all. For example, if a patent 329: license would not permit royalty-free redistribution of the Program by 330: all those who receive copies directly or indirectly through you, then 331: the only way you could satisfy both it and this License would be to 332: refrain entirely from distribution of the Program. 333: 334: If any portion of this section is held invalid or unenforceable under 335: any particular circumstance, the balance of the section is intended to 336: apply and the section as a whole is intended to apply in other 337: circumstances. 338: 339: It is not the purpose of this section to induce you to infringe any 340: patents or other property right claims or to contest validity of any 341: such claims; this section has the sole purpose of protecting the 342: integrity of the free software distribution system, which is 343: implemented by public license practices. Many people have made 344: generous contributions to the wide range of software distributed 345: through that system in reliance on consistent application of that 346: system; it is up to the author/donor to decide if he or she is willing 347: to distribute software through any other system and a licensee cannot 348: impose that choice. 349: 350: This section is intended to make thoroughly clear what is believed to 351: be a consequence of the rest of this License. 352: 353: @item 354: If the distribution and/or use of the Program is restricted in 355: certain countries either by patents or by copyrighted interfaces, the 356: original copyright holder who places the Program under this License 357: may add an explicit geographical distribution limitation excluding 358: those countries, so that distribution is permitted only in or among 359: countries not thus excluded. In such case, this License incorporates 360: the limitation as if written in the body of this License. 361: 362: @item 363: The Free Software Foundation may publish revised and/or new versions 364: of the General Public License from time to time. Such new versions will 365: be similar in spirit to the present version, but may differ in detail to 366: address new problems or concerns. 367: 368: Each version is given a distinguishing version number. If the Program 369: specifies a version number of this License which applies to it and ``any 370: later version'', you have the option of following the terms and conditions 371: either of that version or of any later version published by the Free 372: Software Foundation. If the Program does not specify a version number of 373: this License, you may choose any version ever published by the Free Software 374: Foundation. 375: 376: @item 377: If you wish to incorporate parts of the Program into other free 378: programs whose distribution conditions are different, write to the author 379: to ask for permission. For software which is copyrighted by the Free 380: Software Foundation, write to the Free Software Foundation; we sometimes 381: make exceptions for this. Our decision will be guided by the two goals 382: of preserving the free status of all derivatives of our free software and 383: of promoting the sharing and reuse of software generally. 384: 385: @iftex 386: @heading NO WARRANTY 387: @end iftex 388: @ifinfo 389: @center NO WARRANTY 390: @end ifinfo 391: 392: @item 393: BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY 394: FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN 395: OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES 396: PROVIDE THE PROGRAM ``AS IS'' WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED 397: OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 398: MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS 399: TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE 400: PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, 401: REPAIR OR CORRECTION. 402: 403: @item 404: IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING 405: WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR 406: REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, 407: INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING 408: OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED 409: TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY 410: YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER 411: PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE 412: POSSIBILITY OF SUCH DAMAGES. 413: @end enumerate 414: 415: @iftex 416: @heading END OF TERMS AND CONDITIONS 417: @end iftex 418: @ifinfo 419: @center END OF TERMS AND CONDITIONS 420: @end ifinfo 421: 422: @page 423: @unnumberedsec How to Apply These Terms to Your New Programs 424: 425: If you develop a new program, and you want it to be of the greatest 426: possible use to the public, the best way to achieve this is to make it 427: free software which everyone can redistribute and change under these terms. 428: 429: To do so, attach the following notices to the program. It is safest 430: to attach them to the start of each source file to most effectively 431: convey the exclusion of warranty; and each file should have at least 432: the ``copyright'' line and a pointer to where the full notice is found. 433: 434: @smallexample 435: @var{one line to give the program's name and a brief idea of what it does.} 436: Copyright (C) 19@var{yy} @var{name of author} 437: 438: This program is free software; you can redistribute it and/or modify 439: it under the terms of the GNU General Public License as published by 440: the Free Software Foundation; either version 2 of the License, or 441: (at your option) any later version. 442: 443: This program is distributed in the hope that it will be useful, 444: but WITHOUT ANY WARRANTY; without even the implied warranty of 445: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 446: GNU General Public License for more details. 447: 448: You should have received a copy of the GNU General Public License 449: along with this program; if not, write to the Free Software 450: Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 451: @end smallexample 452: 453: Also add information on how to contact you by electronic and paper mail. 454: 455: If the program is interactive, make it output a short notice like this 456: when it starts in an interactive mode: 457: 458: @smallexample 459: Gnomovision version 69, Copyright (C) 19@var{yy} @var{name of author} 460: Gnomovision comes with ABSOLUTELY NO WARRANTY; for details 461: type `show w'. 462: This is free software, and you are welcome to redistribute it 463: under certain conditions; type `show c' for details. 464: @end smallexample 465: 466: The hypothetical commands @samp{show w} and @samp{show c} should show 467: the appropriate parts of the General Public License. Of course, the 468: commands you use may be called something other than @samp{show w} and 469: @samp{show c}; they could even be mouse-clicks or menu items---whatever 470: suits your program. 471: 472: You should also get your employer (if you work as a programmer) or your 473: school, if any, to sign a ``copyright disclaimer'' for the program, if 474: necessary. Here is a sample; alter the names: 475: 476: @smallexample 477: Yoyodyne, Inc., hereby disclaims all copyright interest in the program 478: `Gnomovision' (which makes passes at compilers) written by James Hacker. 479: 480: @var{signature of Ty Coon}, 1 April 1989 481: Ty Coon, President of Vice 482: @end smallexample 483: 484: This General Public License does not permit incorporating your program into 485: proprietary programs. If your program is a subroutine library, you may 486: consider it more useful to permit linking proprietary applications with the 487: library. If this is what you want to do, use the GNU Library General 488: Public License instead of this License. 1.1 anton 489: 490: @iftex 1.23 pazsan 491: @node Preface 492: @comment node-name, next, previous, up 1.1 anton 493: @unnumbered Preface 1.23 pazsan 494: @cindex Preface 1.17 anton 495: This manual documents Gforth. The reader is expected to know 1.1 anton 496: Forth. This manual is primarily a reference manual. @xref{Other Books} 497: for introductory material. 498: @end iftex 499: 500: @node Goals, Other Books, License, Top 501: @comment node-name, next, previous, up 1.17 anton 502: @chapter Goals of Gforth 1.1 anton 503: @cindex Goals 1.17 anton 504: The goal of the Gforth Project is to develop a standard model for 1.1 anton 505: ANSI Forth. This can be split into several subgoals: 506: 507: @itemize @bullet 508: @item 1.17 anton 509: Gforth should conform to the ANSI Forth standard. 1.1 anton 510: @item 511: It should be a model, i.e. it should define all the 512: implementation-dependent things. 513: @item 514: It should become standard, i.e. widely accepted and used. This goal 515: is the most difficult one. 516: @end itemize 517: 1.17 anton 518: To achieve these goals Gforth should be 1.1 anton 519: @itemize @bullet 520: @item 521: Similar to previous models (fig-Forth, F83) 522: @item 523: Powerful. It should provide for all the things that are considered 524: necessary today and even some that are not yet considered necessary. 525: @item 526: Efficient. It should not get the reputation of being exceptionally 527: slow. 528: @item 529: Free. 530: @item 531: Available on many machines/easy to port. 532: @end itemize 533: 1.17 anton 534: Have we achieved these goals? Gforth conforms to the ANS Forth 535: standard. It may be considered a model, but we have not yet documented 1.1 anton 536: which parts of the model are stable and which parts we are likely to 1.17 anton 537: change. It certainly has not yet become a de facto standard. It has some 538: similarities and some differences to previous models. It has some 539: powerful features, but not yet everything that we envisioned. We 540: certainly have achieved our execution speed goals (@pxref{Performance}). 541: It is free and available on many machines. 1.1 anton 542: 543: @node Other Books, Invocation, Goals, Top 544: @chapter Other books on ANS Forth 545: 546: As the standard is relatively new, there are not many books out yet. It 1.17 anton 547: is not recommended to learn Forth by using Gforth and a book that is 1.1 anton 548: not written for ANS Forth, as you will not know your mistakes from the 549: deviations of the book. 550: 551: There is, of course, the standard, the definite reference if you want to 1.19 anton 552: write ANS Forth programs. It is available in printed form from the 553: National Standards Institute Sales Department (Tel.: USA (212) 642-4900; 554: Fax.: USA (212) 302-1286) as document @cite{X3.215-1994} for about $200. You 555: can also get it from Global Engineering Documents (Tel.: USA (800) 556: 854-7179; Fax.: (303) 843-9880) for about $300. 557: 558: @cite{dpANS6}, the last draft of the standard, which was then submitted to ANSI 559: for publication is available electronically and for free in some MS Word 560: format, and it has been converted to HTML. Some pointers to these 561: versions can be found through 1.24 ! anton 562: @*@file{}. 1.1 anton 563: 1.21 anton 564: @cite{Forth: The new model} by Jack Woehr (Prentice-Hall, 1993) is an 1.1 anton 565: introductory book based on a draft version of the standard. It does not 566: cover the whole standard. It also contains interesting background 567: information (Jack Woehr was in the ANS Forth Technical Committe). It is 568: not appropriate for complete newbies, but programmers experienced in 569: other languages should find it ok. 570: 571: @node Invocation, Words, Other Books, Top 572: @chapter Invocation 573: 574: You will usually just say @code{gforth}. In many other cases the default 1.17 anton 575: Gforth image will be invoked like this: 1.1 anton 576: 577: @example 578: gforth [files] [-e forth-code] 579: @end example 580: 581: executing the contents of the files and the Forth code in the order they 582: are given. 583: 584: In general, the command line looks like this: 585: 586: @example 587: gforth [initialization options] [image-specific options] 588: @end example 589: 590: The initialization options must come before the rest of the command 591: line. They are: 592: 593: @table @code 594: @item --image-file @var{file} 1.20 pazsan 595: @item -i @var{file} 1.1 anton 596: Loads the Forth image @var{file} instead of the default 597: @file{gforth.fi}. 598: 599: @item --path @var{path} 1.20 pazsan 600: @item -p @var{path} 1.1 anton 601: Uses @var{path} for searching the image file and Forth source code 602: files instead of the default in the environment variable 603: @code{GFORTHPATH} or the path specified at installation time (typically 604: @file{/usr/local/lib/gforth:.}). A path is given as a @code{:}-separated 605: list. 606: 607: @item --dictionary-size @var{size} 608: @item -m @var{size} 609: Allocate @var{size} space for the Forth dictionary space instead of 610: using the default specified in the image (typically 256K). The 611: @var{size} specification consists of an integer and a unit (e.g., 612: @code{4M}). The unit can be one of @code{b} (bytes), @code{e} (element 613: size, in this case Cells), @code{k} (kilobytes), and @code{M} 614: (Megabytes). If no unit is specified, @code{e} is used. 615: 616: @item --data-stack-size @var{size} 617: @item -d @var{size} 618: Allocate @var{size} space for the data stack instead of using the 619: default specified in the image (typically 16K). 620: 621: @item --return-stack-size @var{size} 622: @item -r @var{size} 623: Allocate @var{size} space for the return stack instead of using the 624: default specified in the image (typically 16K). 625: 626: @item --fp-stack-size @var{size} 627: @item -f @var{size} 628: Allocate @var{size} space for the floating point stack instead of 629: using the default specified in the image (typically 16K). In this case 630: the unit specifier @code{e} refers to floating point numbers. 631: 632: @item --locals-stack-size @var{size} 633: @item -l @var{size} 634: Allocate @var{size} space for the locals stack instead of using the 635: default specified in the image (typically 16K). 636: 637: @end table 638: 639: As explained above, the image-specific command-line arguments for the 640: default image @file{gforth.fi} consist of a sequence of filenames and 641: @code{-e @var{forth-code}} options that are interpreted in the seqence 642: in which they are given. The @code{-e @var{forth-code}} or 643: @code{--evaluate @var{forth-code}} option evaluates the forth 644: code. This option takes only one argument; if you want to evaluate more 645: Forth words, you have to quote them or use several @code{-e}s. To exit 646: after processing the command line (instead of entering interactive mode) 647: append @code{-e bye} to the command line. 648: 1.22 anton 649: If you have several versions of Gforth installed, @code{gforth} will 650: invoke the version that was installed last. @code{gforth-@var{version}} 651: invokes a specific version. You may want to use the option 652: @code{--path}, if your environment contains the variable 653: @code{GFORTHPATH}. 654: 1.1 anton 655: Not yet implemented: 656: On startup the system first executes the system initialization file 657: (unless the option @code{--no-init-file} is given; note that the system 658: resulting from using this option may not be ANS Forth conformant). Then 659: the user initialization file @file{.gforth.fs} is executed, unless the 660: option @code{--no-rc} is given; this file is first searched in @file{.}, 661: then in @file{~}, then in the normal path (see above). 662: 1.4 anton 663: @node Words, ANS conformance, Invocation, Top 1.1 anton 664: @chapter Forth Words 665: 666: @menu 1.4 anton 667: * Notation:: 668: * Arithmetic:: 669: * Stack Manipulation:: 670: * Memory access:: 671: * Control Structures:: 672: * Locals:: 673: * Defining Words:: 674: * Wordlists:: 675: * Files:: 676: * Blocks:: 677: * Other I/O:: 678: * Programming Tools:: 1.18 anton 679: * Assembler and Code words:: 1.4 anton 680: * Threading Words:: 1.1 anton 681: @end menu 682: 683: @node Notation, Arithmetic, Words, Words 684: @section Notation 685: 686: The Forth words are described in this section in the glossary notation 687: that has become a de-facto standard for Forth texts, i.e. 688: 1.4 anton 689: @format 1.1 anton 690: @var{word} @var{Stack effect} @var{wordset} @var{pronunciation} 1.4 anton 691: @end format 1.1 anton 692: @var{Description} 693: 694: @table @var 695: @item word 1.17 anton 696: The name of the word. BTW, Gforth is case insensitive, so you can 1.14 anton 697: type the words in in lower case (However, @pxref{core-idef}). 1.1 anton 698: 699: @item Stack effect 700: The stack effect is written in the notation @code{@var{before} -- 701: @var{after}}, where @var{before} and @var{after} describe the top of 702: stack entries before and after the execution of the word. The rest of 703: the stack is not touched by the word. The top of stack is rightmost, 1.17 anton 704: i.e., a stack sequence is written as it is typed in. Note that Gforth 1.1 anton 705: uses a separate floating point stack, but a unified stack 706: notation. Also, return stack effects are not shown in @var{stack 707: effect}, but in @var{Description}. The name of a stack item describes 708: the type and/or the function of the item. See below for a discussion of 709: the types. 710: 1.19 anton 711: All words have two stack effects: A compile-time stack effect and a 712: run-time stack effect. The compile-time stack-effect of most words is 713: @var{ -- }. If the compile-time stack-effect of a word deviates from 714: this standard behaviour, or the word does other unusual things at 715: compile time, both stack effects are shown; otherwise only the run-time 716: stack effect is shown. 717: 1.1 anton 718: @item pronunciation 719: How the word is pronounced 720: 721: @item wordset 722: The ANS Forth standard is divided into several wordsets. A standard 723: system need not support all of them. So, the fewer wordsets your program 724: uses the more portable it will be in theory. However, we suspect that 725: most ANS Forth systems on personal machines will feature all 726: wordsets. Words that are not defined in the ANS standard have 1.19 anton 727: @code{gforth} or @code{gforth-internal} as wordset. @code{gforth} 728: describes words that will work in future releases of Gforth; 729: @code{gforth-internal} words are more volatile. Environmental query 730: strings are also displayed like words; you can recognize them by the 731: @code{environment} in the wordset field. 1.1 anton 732: 733: @item Description 734: A description of the behaviour of the word. 735: @end table 736: 1.4 anton 737: The type of a stack item is specified by the character(s) the name 738: starts with: 1.1 anton 739: 740: @table @code 741: @item f 742: Bool, i.e. @code{false} or @code{true}. 743: @item c 744: Char 745: @item w 746: Cell, can contain an integer or an address 747: @item n 748: signed integer 749: @item u 750: unsigned integer 751: @item d 752: double sized signed integer 753: @item ud 754: double sized unsigned integer 755: @item r 756: Float 757: @item a_ 758: Cell-aligned address 759: @item c_ 760: Char-aligned address (note that a Char is two bytes in Windows NT) 761: @item f_ 762: Float-aligned address 763: @item df_ 764: Address aligned for IEEE double precision float 765: @item sf_ 766: Address aligned for IEEE single precision float 767: @item xt 768: Execution token, same size as Cell 769: @item wid 770: Wordlist ID, same size as Cell 771: @item f83name 772: Pointer to a name structure 773: @end table 774: 1.4 anton 775: @node Arithmetic, Stack Manipulation, Notation, Words 1.1 anton 776: @section Arithmetic 777: Forth arithmetic is not checked, i.e., you will not hear about integer 778: overflow on addition or multiplication, you may hear about division by 779: zero if you are lucky. The operator is written after the operands, but 780: the operands are still in the original order. I.e., the infix @code{2-1} 781: corresponds to @code{2 1 -}. Forth offers a variety of division 782: operators. If you perform division with potentially negative operands, 783: you do not want to use @code{/} or @code{/mod} with its undefined 784: behaviour, but rather @code{fm/mod} or @code{sm/mod} (probably the 1.4 anton 785: former, @pxref{Mixed precision}). 786: 787: @menu 788: * Single precision:: 789: * Bitwise operations:: 790: * Mixed precision:: operations with single and double-cell integers 791: * Double precision:: Double-cell integer arithmetic 792: * Floating Point:: 793: @end menu 1.1 anton 794: 1.4 anton 795: @node Single precision, Bitwise operations, Arithmetic, Arithmetic 1.1 anton 796: @subsection Single precision 797: doc-+ 798: doc-- 799: doc-* 800: doc-/ 801: doc-mod 802: doc-/mod 803: doc-negate 804: doc-abs 805: doc-min 806: doc-max 807: 1.4 anton 808: @node Bitwise operations, Mixed precision, Single precision, Arithmetic 1.1 anton 809: @subsection Bitwise operations 810: doc-and 811: doc-or 812: doc-xor 813: doc-invert 814: doc-2* 815: doc-2/ 816: 1.4 anton 817: @node Mixed precision, Double precision, Bitwise operations, Arithmetic 1.1 anton 818: @subsection Mixed precision 819: doc-m+ 820: doc-*/ 821: doc-*/mod 822: doc-m* 823: doc-um* 824: doc-m*/ 825: doc-um/mod 826: doc-fm/mod 827: doc-sm/rem 828: 1.4 anton 829: @node Double precision, Floating Point, Mixed precision, Arithmetic 1.1 anton 830: @subsection Double precision 1.16 anton 831: 832: The outer (aka text) interpreter converts numbers containing a dot into 833: a double precision number. Note that only numbers with the dot as last 834: character are standard-conforming. 835: 1.1 anton 836: doc-d+ 837: doc-d- 838: doc-dnegate 839: doc-dabs 840: doc-dmin 841: doc-dmax 842: 1.4 anton 843: @node Floating Point, , Double precision, Arithmetic 844: @subsection Floating Point 1.16 anton 845: 846: The format of floating point numbers recognized by the outer (aka text) 847: interpreter is: a signed decimal number, possibly containing a decimal 848: point (@code{.}), followed by @code{E} or @code{e}, optionally followed 849: by a signed integer (the exponent). E.g., @code{1e} ist the same as 850: @code{+1.0e+1}. Note that a number without @code{e} 851: is not interpreted as floating-point number, but as double (if the 852: number contains a @code{.}) or single precision integer. Also, 853: conversions between string and floating point numbers always use base 854: 10, irrespective of the value of @code{BASE}. If @code{BASE} contains a 855: value greater then 14, the @code{E} may be interpreted as digit and the 856: number will be interpreted as integer, unless it has a signed exponent 857: (both @code{+} and @code{-} are allowed as signs). 1.4 anton 858: 859: Angles in floating point operations are given in radians (a full circle 1.17 anton 860: has 2 pi radians). Note, that Gforth has a separate floating point 1.4 anton 861: stack, but we use the unified notation. 862: 863: Floating point numbers have a number of unpleasant surprises for the 864: unwary (e.g., floating point addition is not associative) and even a few 865: for the wary. You should not use them unless you know what you are doing 866: or you don't care that the results you get are totally bogus. If you 867: want to learn about the problems of floating point numbers (and how to 1.11 anton 868: avoid them), you might start with @cite{David Goldberg, What Every 1.6 anton 869: Computer Scientist Should Know About Floating-Point Arithmetic, ACM 870: Computing Surveys 23(1):5@minus{}48, March 1991}. 1.4 anton 871: 872: doc-f+ 873: doc-f- 874: doc-f* 875: doc-f/ 876: doc-fnegate 877: doc-fabs 878: doc-fmax 879: doc-fmin 880: doc-floor 881: doc-fround 882: doc-f** 883: doc-fsqrt 884: doc-fexp 885: doc-fexpm1 886: doc-fln 887: doc-flnp1 888: doc-flog 1.6 anton 889: doc-falog 1.4 anton 890: doc-fsin 891: doc-fcos 892: doc-fsincos 893: doc-ftan 894: doc-fasin 895: doc-facos 896: doc-fatan 897: doc-fatan2 898: doc-fsinh 899: doc-fcosh 900: doc-ftanh 901: doc-fasinh 902: doc-facosh 903: doc-fatanh 904: 905: @node Stack Manipulation, Memory access, Arithmetic, Words 1.1 anton 906: @section Stack Manipulation 907: 1.17 anton 908: Gforth has a data stack (aka parameter stack) for characters, cells, 1.1 anton 909: addresses, and double cells, a floating point stack for floating point 910: numbers, a return stack for storing the return addresses of colon 911: definitions and other data, and a locals stack for storing local 912: variables. Note that while every sane Forth has a separate floating 913: point stack, this is not strictly required; an ANS Forth system could 914: theoretically keep floating point numbers on the data stack. As an 915: additional difficulty, you don't know how many cells a floating point 916: number takes. It is reportedly possible to write words in a way that 917: they work also for a unified stack model, but we do not recommend trying 1.4 anton 918: it. Instead, just say that your program has an environmental dependency 919: on a separate FP stack. 920: 921: Also, a Forth system is allowed to keep the local variables on the 1.1 anton 922: return stack. This is reasonable, as local variables usually eliminate 923: the need to use the return stack explicitly. So, if you want to produce 924: a standard complying program and if you are using local variables in a 925: word, forget about return stack manipulations in that word (see the 926: standard document for the exact rules). 927: 1.4 anton 928: @menu 929: * Data stack:: 930: * Floating point stack:: 931: * Return stack:: 932: * Locals stack:: 933: * Stack pointer manipulation:: 934: @end menu 935: 936: @node Data stack, Floating point stack, Stack Manipulation, Stack Manipulation 1.1 anton 937: @subsection Data stack 938: doc-drop 939: doc-nip 940: doc-dup 941: doc-over 942: doc-tuck 943: doc-swap 944: doc-rot 945: doc--rot 946: doc-?dup 947: doc-pick 948: doc-roll 949: doc-2drop 950: doc-2nip 951: doc-2dup 952: doc-2over 953: doc-2tuck 954: doc-2swap 955: doc-2rot 956: 1.4 anton 957: @node Floating point stack, Return stack, Data stack, Stack Manipulation 1.1 anton 958: @subsection Floating point stack 959: doc-fdrop 960: doc-fnip 961: doc-fdup 962: doc-fover 963: doc-ftuck 964: doc-fswap 965: doc-frot 966: 1.4 anton 967: @node Return stack, Locals stack, Floating point stack, Stack Manipulation 1.1 anton 968: @subsection Return stack 969: doc->r 970: doc-r> 971: doc-r@ 972: doc-rdrop 973: doc-2>r 974: doc-2r> 975: doc-2r@ 976: doc-2rdrop 977: 1.4 anton 978: @node Locals stack, Stack pointer manipulation, Return stack, Stack Manipulation 1.1 anton 979: @subsection Locals stack 980: 1.4 anton 981: @node Stack pointer manipulation, , Locals stack, Stack Manipulation 1.1 anton 982: @subsection Stack pointer manipulation 983: doc-sp@ 984: doc-sp! 985: doc-fp@ 986: doc-fp! 987: doc-rp@ 988: doc-rp! 989: doc-lp@ 990: doc-lp! 991: 1.4 anton 992: @node Memory access, Control Structures, Stack Manipulation, Words 1.1 anton 993: @section Memory access 994: 1.4 anton 995: @menu 996: * Stack-Memory transfers:: 997: * Address arithmetic:: 998: * Memory block access:: 999: @end menu 1000: 1001: @node Stack-Memory transfers, Address arithmetic, Memory access, Memory access 1.1 anton 1002: @subsection Stack-Memory transfers 1003: 1004: doc-@ 1005: doc-! 1006: doc-+! 1007: doc-c@ 1008: doc-c! 1009: doc-2@ 1010: doc-2! 1011: doc-f@ 1012: doc-f! 1013: doc-sf@ 1014: doc-sf! 1015: doc-df@ 1016: doc-df! 1017: 1.4 anton 1018: @node Address arithmetic, Memory block access, Stack-Memory transfers, Memory access 1.1 anton 1019: @subsection Address arithmetic 1020: 1021: ANS Forth does not specify the sizes of the data types. Instead, it 1022: offers a number of words for computing sizes and doing address 1023: arithmetic. Basically, address arithmetic is performed in terms of 1024: address units (aus); on most systems the address unit is one byte. Note 1025: that a character may have more than one au, so @code{chars} is no noop 1026: (on systems where it is a noop, it compiles to nothing). 1027: 1028: ANS Forth also defines words for aligning addresses for specific 1029: addresses. Many computers require that accesses to specific data types 1030: must only occur at specific addresses; e.g., that cells may only be 1031: accessed at addresses divisible by 4. Even if a machine allows unaligned 1032: accesses, it can usually perform aligned accesses faster. 1033: 1.17 anton 1034: For the performance-conscious: alignment operations are usually only 1.1 anton 1035: necessary during the definition of a data structure, not during the 1036: (more frequent) accesses to it. 1037: 1038: ANS Forth defines no words for character-aligning addresses. This is not 1039: an oversight, but reflects the fact that addresses that are not 1040: char-aligned have no use in the standard and therefore will not be 1041: created. 1042: 1043: The standard guarantees that addresses returned by @code{CREATE}d words 1.17 anton 1044: are cell-aligned; in addition, Gforth guarantees that these addresses 1.1 anton 1045: are aligned for all purposes. 1046: 1.9 anton 1047: Note that the standard defines a word @code{char}, which has nothing to 1048: do with address arithmetic. 1049: 1.1 anton 1050: doc-chars 1051: doc-char+ 1052: doc-cells 1053: doc-cell+ 1054: doc-align 1055: doc-aligned 1056: doc-floats 1057: doc-float+ 1058: doc-falign 1059: doc-faligned 1060: doc-sfloats 1061: doc-sfloat+ 1062: doc-sfalign 1063: doc-sfaligned 1064: doc-dfloats 1065: doc-dfloat+ 1066: doc-dfalign 1067: doc-dfaligned 1.10 anton 1068: doc-maxalign 1069: doc-maxaligned 1070: doc-cfalign 1071: doc-cfaligned 1.1 anton 1072: doc-address-unit-bits 1073: 1.4 anton 1074: @node Memory block access, , Address arithmetic, Memory access 1.1 anton 1075: @subsection Memory block access 1076: 1077: doc-move 1078: doc-erase 1079: 1080: While the previous words work on address units, the rest works on 1081: characters. 1082: 1083: doc-cmove 1084: doc-cmove> 1085: doc-fill 1086: doc-blank 1087: 1.4 anton 1088: @node Control Structures, Locals, Memory access, Words 1.1 anton 1089: @section Control Structures 1090: 1091: Control structures in Forth cannot be used in interpret state, only in 1092: compile state, i.e., in a colon definition. We do not like this 1093: limitation, but have not seen a satisfying way around it yet, although 1094: many schemes have been proposed. 1095: 1.4 anton 1096: @menu 1097: * Selection:: 1098: * Simple Loops:: 1099: * Counted Loops:: 1100: * Arbitrary control structures:: 1101: * Calls and returns:: 1102: * Exception Handling:: 1103: @end menu 1104: 1105: @node Selection, Simple Loops, Control Structures, Control Structures 1.1 anton 1106: @subsection Selection 1107: 1108: @example 1109: @var{flag} 1110: IF 1111: @var{code} 1112: ENDIF 1113: @end example 1114: or 1115: @example 1116: @var{flag} 1117: IF 1118: @var{code1} 1119: ELSE 1120: @var{code2} 1121: ENDIF 1122: @end example 1123: 1.4 anton 1124: You can use @code{THEN} instead of @code{ENDIF}. Indeed, @code{THEN} is 1.1 anton 1125: standard, and @code{ENDIF} is not, although it is quite popular. We 1126: recommend using @code{ENDIF}, because it is less confusing for people 1127: who also know other languages (and is not prone to reinforcing negative 1128: prejudices against Forth in these people). Adding @code{ENDIF} to a 1129: system that only supplies @code{THEN} is simple: 1130: @example 1131: : endif POSTPONE then ; immediate 1132: @end example 1133: 1134: [According to @cite{Webster's New Encyclopedic Dictionary}, @dfn{then 1135: (adv.)} has the following meanings: 1136: @quotation 1137: ... 2b: following next after in order ... 3d: as a necessary consequence 1138: (if you were there, then you saw them). 1139: @end quotation 1140: Forth's @code{THEN} has the meaning 2b, whereas @code{THEN} in Pascal 1141: and many other programming languages has the meaning 3d.] 1142: 1143: We also provide the words @code{?dup-if} and @code{?dup-0=-if}, so you 1144: can avoid using @code{?dup}. 1145: 1146: @example 1147: @var{n} 1148: CASE 1149: @var{n1} OF @var{code1} ENDOF 1150: @var{n2} OF @var{code2} ENDOF 1.4 anton 1151: @dots{} 1.1 anton 1152: ENDCASE 1153: @end example 1154: 1155: Executes the first @var{codei}, where the @var{ni} is equal to 1156: @var{n}. A default case can be added by simply writing the code after 1157: the last @code{ENDOF}. It may use @var{n}, which is on top of the stack, 1158: but must not consume it. 1159: 1.4 anton 1160: @node Simple Loops, Counted Loops, Selection, Control Structures 1.1 anton 1161: @subsection Simple Loops 1162: 1163: @example 1164: BEGIN 1165: @var{code1} 1166: @var{flag} 1167: WHILE 1168: @var{code2} 1169: REPEAT 1170: @end example 1171: 1172: @var{code1} is executed and @var{flag} is computed. If it is true, 1173: @var{code2} is executed and the loop is restarted; If @var{flag} is false, execution continues after the @code{REPEAT}. 1174: 1175: @example 1176: BEGIN 1177: @var{code} 1178: @var{flag} 1179: UNTIL 1180: @end example 1181: 1182: @var{code} is executed. The loop is restarted if @code{flag} is false. 1183: 1184: @example 1185: BEGIN 1186: @var{code} 1187: AGAIN 1188: @end example 1189: 1190: This is an endless loop. 1191: 1.4 anton 1192: @node Counted Loops, Arbitrary control structures, Simple Loops, Control Structures 1.1 anton 1193: @subsection Counted Loops 1194: 1195: The basic counted loop is: 1196: @example 1197: @var{limit} @var{start} 1198: ?DO 1199: @var{body} 1200: LOOP 1201: @end example 1202: 1203: This performs one iteration for every integer, starting from @var{start} 1204: and up to, but excluding @var{limit}. The counter, aka index, can be 1205: accessed with @code{i}. E.g., the loop 1206: @example 1207: 10 0 ?DO 1208: i . 1209: LOOP 1210: @end example 1211: prints 1212: @example 1213: 0 1 2 3 4 5 6 7 8 9 1214: @end example 1215: The index of the innermost loop can be accessed with @code{i}, the index 1216: of the next loop with @code{j}, and the index of the third loop with 1217: @code{k}. 1218: 1219: The loop control data are kept on the return stack, so there are some 1220: restrictions on mixing return stack accesses and counted loop 1221: words. E.g., if you put values on the return stack outside the loop, you 1222: cannot read them inside the loop. If you put values on the return stack 1223: within a loop, you have to remove them before the end of the loop and 1224: before accessing the index of the loop. 1225: 1226: There are several variations on the counted loop: 1227: 1228: @code{LEAVE} leaves the innermost counted loop immediately. 1229: 1.18 anton 1230: If @var{start} is greater than @var{limit}, a @code{?DO} loop is entered 1231: (and @code{LOOP} iterates until they become equal by wrap-around 1232: arithmetic). This behaviour is usually not what you want. Therefore, 1233: Gforth offers @code{+DO} and @code{U+DO} (as replacements for 1234: @code{?DO}), which do not enter the loop if @var{start} is greater than 1235: @var{limit}; @code{+DO} is for signed loop parameters, @code{U+DO} for 1236: unsigned loop parameters. These words can be implemented easily on 1237: standard systems, so using them does not make your programs hard to 1238: port; e.g.: 1239: @example 1240: : +DO ( compile-time: -- do-sys; run-time: n1 n2 -- ) 1241: POSTPONE over POSTPONE min POSTPONE ?DO ; immediate 1242: @end example 1243: 1.1 anton 1244: @code{LOOP} can be replaced with @code{@var{n} +LOOP}; this updates the 1245: index by @var{n} instead of by 1. The loop is terminated when the border 1246: between @var{limit-1} and @var{limit} is crossed. E.g.: 1247: 1.18 anton 1248: @code{4 0 +DO i . 2 +LOOP} prints @code{0 2} 1.1 anton 1249: 1.18 anton 1250: @code{4 1 +DO i . 2 +LOOP} prints @code{1 3} 1.1 anton 1251: 1252: The behaviour of @code{@var{n} +LOOP} is peculiar when @var{n} is negative: 1253: 1.2 anton 1254: @code{-1 0 ?DO i . -1 +LOOP} prints @code{0 -1} 1.1 anton 1255: 1.2 anton 1256: @code{ 0 0 ?DO i . -1 +LOOP} prints nothing 1.1 anton 1257: 1.18 anton 1258: Therefore we recommend avoiding @code{@var{n} +LOOP} with negative 1259: @var{n}. One alternative is @code{@var{u} -LOOP}, which reduces the 1260: index by @var{u} each iteration. The loop is terminated when the border 1261: between @var{limit+1} and @var{limit} is crossed. Gforth also provides 1262: @code{-DO} and @code{U-DO} for down-counting loops. E.g.: 1.1 anton 1263: 1.18 anton 1264: @code{-2 0 -DO i . 1 -LOOP} prints @code{0 -1} 1.1 anton 1265: 1.18 anton 1266: @code{-1 0 -DO i . 1 -LOOP} prints @code{0} 1.1 anton 1267: 1.18 anton 1268: @code{ 0 0 -DO i . 1 -LOOP} prints nothing 1.1 anton 1269: 1.18 anton 1270: Another alternative is @code{@var{n} S+LOOP}, where the negative 1271: case behaves symmetrical to the positive case: 1.1 anton 1272: 1.18 anton 1273: @code{-2 0 -DO i . -1 S+LOOP} prints @code{0 -1} 1274: 1275: The loop is terminated when the border between @var{limit@minus{}sgn(n)} 1276: and @var{limit} is crossed. Unfortunately, neither @code{-LOOP} nor 1277: @code{S+LOOP} are part of the ANS Forth standard, and they are not easy 1278: to implement using standard words. If you want to write standard 1279: programs, just avoid counting down. 1302: they support @code{FOR} loops. 1303: 1.4 anton 1304: @node Arbitrary control structures, Calls and returns, Counted Loops, Control Structures 1.2 anton 1305: @subsection Arbitrary control structures 1306: 1307: ANS Forth permits and supports using control structures in a non-nested 1308: way. Information about incomplete control structures is stored on the 1309: control-flow stack. This stack may be implemented on the Forth data 1.17 anton 1310: stack, and this is what we have done in Gforth. 1.2 anton 1311: 1312: An @i{orig} entry represents an unresolved forward branch, a @i{dest} 1313: entry represents a backward branch target. A few words are the basis for 1314: building any control structure possible (except control structures that 1315: need storage, like calls, coroutines, and backtracking). 1316: 1.3 anton 1317: doc-if 1318: doc-ahead 1319: doc-then 1320: doc-begin 1321: doc-until 1322: doc-again 1323: doc-cs-pick 1324: doc-cs-roll 1.2 anton 1325: 1.17 anton 1326: On many systems control-flow stack items take one word, in Gforth they 1.2 anton 1327: currently take three (this may change in the future). Therefore it is a 1328: really good idea to manipulate the control flow stack with 1329: @code{cs-pick} and @code{cs-roll}, not with data stack manipulation 1330: words. 1331: 1332: Some standard control structure words are built from these words: 1333: 1.3 anton 1334: doc-else 1335: doc-while 1336: doc-repeat 1.2 anton 1337:-s+loop 1349: doc-+loop 1.18 anton 1350: doc--loop 1.3 anton 1351: doc-next 1352: doc-leave 1353: doc-?leave 1354: doc-unloop 1.10 anton 1355: doc-done 1.2 anton 1356: 1357: The standard does not allow using @code{cs-pick} and @code{cs-roll} on 1358: @i{do-sys}. Our system allows it, but it's your job to ensure that for 1359: every @code{?DO} etc. there is exactly one @code{UNLOOP} on any path 1.3 anton 1360: through the definition (@code{LOOP} etc. compile an @code{UNLOOP} on the 1361: fall-through path). Also, you have to ensure that all @code{LEAVE}s are 1.7 pazsan 1362: resolved (by using one of the loop-ending words or @code{DONE}). 1.2 anton 1363: 1364: Another group of control structure words are 1365: 1.3 anton 1366: doc-case 1367: doc-endcase 1368: doc-of 1369: doc-endof 1.2 anton 1370: 1371: @i{case-sys} and @i{of-sys} cannot be processed using @code{cs-pick} and 1372: @code{cs-roll}. 1373: 1.3 anton 1374: @subsubsection Programming Style 1375: 1376: In order to ensure readability we recommend that you do not create 1377: arbitrary control structures directly, but define new control structure 1378: words for the control structure you want and use these words in your 1379: program. 1380: 1381: E.g., instead of writing 1382: 1383: @example 1384: begin 1385: ... 1386: if [ 1 cs-roll ] 1387: ... 1388: again then 1389: @end example 1390: 1391: we recommend defining control structure words, e.g., 1392: 1393: @example 1394: : while ( dest -- orig dest ) 1395: POSTPONE if 1396: 1 cs-roll ; immediate 1397: 1398: : repeat ( orig dest -- ) 1399: POSTPONE again 1400: POSTPONE then ; immediate 1401: @end example 1402: 1403: and then using these to create the control structure: 1404: 1405: @example 1406: begin 1407: ... 1408: while 1409: ... 1410: repeat 1411: @end example 1412: 1413: That's much easier to read, isn't it? Of course, @code{BEGIN} and 1414: @code{WHILE} are predefined, so in this example it would not be 1415: necessary to define them. 1416: 1.4 anton 1417: @node Calls and returns, Exception Handling, Arbitrary control structures, Control Structures 1.3 anton 1418: @subsection Calls and returns 1419: 1420: A definition can be called simply be writing the name of the 1.17 anton 1421: definition. When the end of the definition is reached, it returns. An 1422: earlier return can be forced using 1.3 anton 1423: 1424: doc-exit 1425: 1426: Don't forget to clean up the return stack and @code{UNLOOP} any 1427: outstanding @code{?DO}...@code{LOOP}s before @code{EXIT}ing. The 1428: primitive compiled by @code{EXIT} is 1429: 1430: doc-;s 1431: 1.4 anton 1432: @node Exception Handling, , Calls and returns, Control Structures 1.3 anton 1433: @subsection Exception Handling 1434: 1435: doc-catch 1436: doc-throw 1437: 1.4 anton 1438: @node Locals, Defining Words, Control Structures, Words 1.1 anton 1439: @section Locals 1440: 1.2 anton 1441: Local variables can make Forth programming more enjoyable and Forth 1442: programs easier to read. Unfortunately, the locals of ANS Forth are 1443: laden with restrictions. Therefore, we provide not only the ANS Forth 1444: locals wordset, but also our own, more powerful locals wordset (we 1445: implemented the ANS Forth locals wordset through our locals wordset). 1446: 1.24 ! anton 1447: The ideas in this section have also been published in the paper ! 1448: @cite{Automatic Scoping of Local Variables} by M. Anton Ertl, presented ! 1449: at EuroForth '94; it is available at ! 1450: @*@file{}. ! 1451: 1.2 anton 1452: @menu 1.17 anton 1453: * Gforth locals:: 1.4 anton 1454: * ANS Forth locals:: 1.2 anton 1455: @end menu 1456: 1.17 anton 1457: @node Gforth locals, ANS Forth locals, Locals, Locals 1458: @subsection Gforth locals 1.2 anton 1459: 1460: Locals can be defined with 1461: 1462: @example 1463: @{ local1 local2 ... -- comment @} 1464: @end example 1465: or 1466: @example 1467: @{ local1 local2 ... @} 1468: @end example 1469: 1470: E.g., 1471: @example 1472: : max @{ n1 n2 -- n3 @} 1473: n1 n2 > if 1474: n1 1475: else 1476: n2 1477: endif ; 1478: @end example 1479: 1480: The similarity of locals definitions with stack comments is intended. A 1481: locals definition often replaces the stack comment of a word. The order 1482: of the locals corresponds to the order in a stack comment and everything 1483: after the @code{--} is really a comment. 1484: 1485: This similarity has one disadvantage: It is too easy to confuse locals 1486: declarations with stack comments, causing bugs and making them hard to 1487: find. However, this problem can be avoided by appropriate coding 1488: conventions: Do not use both notations in the same program. If you do, 1489: they should be distinguished using additional means, e.g. by position. 1490: 1491: The name of the local may be preceded by a type specifier, e.g., 1492: @code{F:} for a floating point value: 1493: 1494: @example 1495: : CX* @{ F: Ar F: Ai F: Br F: Bi -- Cr Ci @} 1496: \ complex multiplication 1497: Ar Br f* Ai Bi f* f- 1498: Ar Bi f* Ai Br f* f+ ; 1499: @end example 1500: 1.17 anton 1501: Gforth currently supports cells (@code{W:}, @code{W^}), doubles 1.2 anton 1502: (@code{D:}, @code{D^}), floats (@code{F:}, @code{F^}) and characters 1503: (@code{C:}, @code{C^}) in two flavours: a value-flavoured local (defined 1504: with @code{W:}, @code{D:} etc.) produces its value and can be changed 1505: with @code{TO}. A variable-flavoured local (defined with @code{W^} etc.) 1506: produces its address (which becomes invalid when the variable's scope is 1507: left). E.g., the standard word @code{emit} can be defined in therms of 1508: @code{type} like this: 1509: 1510: @example 1511: : emit @{ C^ char* -- @} 1512: char* 1 type ; 1513: @end example 1514: 1515: A local without type specifier is a @code{W:} local. Both flavours of 1516: locals are initialized with values from the data or FP stack. 1517: 1518: Currently there is no way to define locals with user-defined data 1519: structures, but we are working on it. 1520: 1.17 anton 1521: Gforth allows defining locals everywhere in a colon definition. This 1.7 pazsan 1522: poses the following questions: 1.2 anton 1523: 1.4 anton 1524: @menu 1525: * Where are locals visible by name?:: 1.14 anton 1526: * How long do locals live?:: 1.4 anton 1527: * Programming Style:: 1528: * Implementation:: 1529: @end menu 1530: 1.17 anton 1531: @node Where are locals visible by name?, How long do locals live?, Gforth locals, Gforth locals 1.2 anton 1532: @subsubsection Where are locals visible by name? 1533: 1534: Basically, the answer is that locals are visible where you would expect 1535: it in block-structured languages, and sometimes a little longer. If you 1536: want to restrict the scope of a local, enclose its definition in 1537: @code{SCOPE}...@code{ENDSCOPE}. 1538: 1539: doc-scope 1540: doc-endscope 1541: 1542: These words behave like control structure words, so you can use them 1543: with @code{CS-PICK} and @code{CS-ROLL} to restrict the scope in 1544: arbitrary ways. 1545: 1546: If you want a more exact answer to the visibility question, here's the 1547: basic principle: A local is visible in all places that can only be 1548: reached through the definition of the local@footnote{In compiler 1549: construction terminology, all places dominated by the definition of the 1550: local.}. In other words, it is not visible in places that can be reached 1551: without going through the definition of the local. E.g., locals defined 1552: in @code{IF}...@code{ENDIF} are visible until the @code{ENDIF}, locals 1553: defined in @code{BEGIN}...@code{UNTIL} are visible after the 1554: @code{UNTIL} (until, e.g., a subsequent @code{ENDSCOPE}). 1555: 1556: The reasoning behind this solution is: We want to have the locals 1557: visible as long as it is meaningful. The user can always make the 1558: visibility shorter by using explicit scoping. In a place that can 1559: only be reached through the definition of a local, the meaning of a 1560: local name is clear. In other places it is not: How is the local 1561: initialized at the control flow path that does not contain the 1562: definition? Which local is meant, if the same name is defined twice in 1563: two independent control flow paths? 1564: 1565: This should be enough detail for nearly all users, so you can skip the 1566: rest of this section. If you relly must know all the gory details and 1567: options, read on. 1568: 1569: In order to implement this rule, the compiler has to know which places 1570: are unreachable. It knows this automatically after @code{AHEAD}, 1571: @code{AGAIN}, @code{EXIT} and @code{LEAVE}; in other cases (e.g., after 1572: most @code{THROW}s), you can use the word @code{UNREACHABLE} to tell the 1573: compiler that the control flow never reaches that place. If 1574: @code{UNREACHABLE} is not used where it could, the only consequence is 1575: that the visibility of some locals is more limited than the rule above 1576: says. If @code{UNREACHABLE} is used where it should not (i.e., if you 1577: lie to the compiler), buggy code will be produced. 1578: 1579: Another problem with this rule is that at @code{BEGIN}, the compiler 1.3 anton 1580: does not know which locals will be visible on the incoming 1581: back-edge. All problems discussed in the following are due to this 1582: ignorance of the compiler (we discuss the problems using @code{BEGIN} 1583: loops as examples; the discussion also applies to @code{?DO} and other 1.2 anton 1584: loops). Perhaps the most insidious example is: 1585: @example 1586: AHEAD 1587: BEGIN 1588: x 1589: [ 1 CS-ROLL ] THEN 1.4 anton 1590: @{ x @} 1.2 anton 1591: ... 1592: UNTIL 1593: @end example 1594: 1595: This should be legal according to the visibility rule. The use of 1596: @code{x} can only be reached through the definition; but that appears 1597: textually below the use. 1598: 1599: From this example it is clear that the visibility rules cannot be fully 1600: implemented without major headaches. Our implementation treats common 1601: cases as advertised and the exceptions are treated in a safe way: The 1602: compiler makes a reasonable guess about the locals visible after a 1603: @code{BEGIN}; if it is too pessimistic, the 1604: user will get a spurious error about the local not being defined; if the 1605: compiler is too optimistic, it will notice this later and issue a 1606: warning. In the case above the compiler would complain about @code{x} 1607: being undefined at its use. You can see from the obscure examples in 1608: this section that it takes quite unusual control structures to get the 1609: compiler into trouble, and even then it will often do fine. 1610: 1611: If the @code{BEGIN} is reachable from above, the most optimistic guess 1612: is that all locals visible before the @code{BEGIN} will also be 1613: visible after the @code{BEGIN}. This guess is valid for all loops that 1614: are entered only through the @code{BEGIN}, in particular, for normal 1615: @code{BEGIN}...@code{WHILE}...@code{REPEAT} and 1616: @code{BEGIN}...@code{UNTIL} loops and it is implemented in our 1617: compiler. When the branch to the @code{BEGIN} is finally generated by 1618: @code{AGAIN} or @code{UNTIL}, the compiler checks the guess and 1619: warns the user if it was too optimisitic: 1620: @example 1621: IF 1.4 anton 1622: @{ x @} 1.2 anton 1623: BEGIN 1624: \ x ? 1625: [ 1 cs-roll ] THEN 1626: ... 1627: UNTIL 1628: @end example 1629: 1630: Here, @code{x} lives only until the @code{BEGIN}, but the compiler 1631: optimistically assumes that it lives until the @code{THEN}. It notices 1632: this difference when it compiles the @code{UNTIL} and issues a 1633: warning. The user can avoid the warning, and make sure that @code{x} 1634: is not used in the wrong area by using explicit scoping: 1635: @example 1636: IF 1637: SCOPE 1.4 anton 1638: @{ x @} 1.2 anton 1639: ENDSCOPE 1640: BEGIN 1641: [ 1 cs-roll ] THEN 1642: ... 1643: UNTIL 1644: @end example 1645: 1646: Since the guess is optimistic, there will be no spurious error messages 1647: about undefined locals. 1648: 1649: If the @code{BEGIN} is not reachable from above (e.g., after 1650: @code{AHEAD} or @code{EXIT}), the compiler cannot even make an 1651: optimistic guess, as the locals visible after the @code{BEGIN} may be 1652: defined later. Therefore, the compiler assumes that no locals are 1.17 anton 1653: visible after the @code{BEGIN}. However, the user can use 1.2 anton 1654: @code{ASSUME-LIVE} to make the compiler assume that the same locals are 1.17 anton 1655: visible at the BEGIN as at the point where the top control-flow stack 1656: item was created. 1.2 anton 1657: 1658: doc-assume-live 1659: 1660: E.g., 1661: @example 1.4 anton 1662: @{ x @} 1.2 anton 1663: AHEAD 1664: ASSUME-LIVE 1665: BEGIN 1666: x 1667: [ 1 CS-ROLL ] THEN 1668: ... 1669: UNTIL 1670: @end example 1671: 1672: Other cases where the locals are defined before the @code{BEGIN} can be 1673: handled by inserting an appropriate @code{CS-ROLL} before the 1674: @code{ASSUME-LIVE} (and changing the control-flow stack manipulation 1675: behind the @code{ASSUME-LIVE}). 1676: 1677: Cases where locals are defined after the @code{BEGIN} (but should be 1678: visible immediately after the @code{BEGIN}) can only be handled by 1679: rearranging the loop. E.g., the ``most insidious'' example above can be 1680: arranged into: 1681: @example 1682: BEGIN 1.4 anton 1683: @{ x @} 1.2 anton 1684: ... 0= 1685: WHILE 1686: x 1687: REPEAT 1688: @end example 1689: 1.17 anton 1690: @node How long do locals live?, Programming Style, Where are locals visible by name?, Gforth locals 1.2 anton 1691: @subsubsection How long do locals live? 1692: 1693: The right answer for the lifetime question would be: A local lives at 1694: least as long as it can be accessed. For a value-flavoured local this 1695: means: until the end of its visibility. However, a variable-flavoured 1696: local could be accessed through its address far beyond its visibility 1697: scope. Ultimately, this would mean that such locals would have to be 1698: garbage collected. Since this entails un-Forth-like implementation 1699: complexities, I adopted the same cowardly solution as some other 1700: languages (e.g., C): The local lives only as long as it is visible; 1701: afterwards its address is invalid (and programs that access it 1702: afterwards are erroneous). 1703: 1.17 anton 1704: @node Programming Style, Implementation, How long do locals live?, Gforth locals 1.2 anton 1705: @subsubsection Programming Style 1706: 1707: The freedom to define locals anywhere has the potential to change 1708: programming styles dramatically. In particular, the need to use the 1709: return stack for intermediate storage vanishes. Moreover, all stack 1710: manipulations (except @code{PICK}s and @code{ROLL}s with run-time 1711: determined arguments) can be eliminated: If the stack items are in the 1712: wrong order, just write a locals definition for all of them; then 1713: write the items in the order you want. 1714: 1715: This seems a little far-fetched and eliminating stack manipulations is 1.4 anton 1716: unlikely to become a conscious programming objective. Still, the number 1717: of stack manipulations will be reduced dramatically if local variables 1.17 anton 1718: are used liberally (e.g., compare @code{max} in @ref{Gforth locals} with 1.4 anton 1719: a traditional implementation of @code{max}). 1.2 anton 1720: 1721: This shows one potential benefit of locals: making Forth programs more 1722: readable. Of course, this benefit will only be realized if the 1723: programmers continue to honour the principle of factoring instead of 1724: using the added latitude to make the words longer. 1725: 1726: Using @code{TO} can and should be avoided. Without @code{TO}, 1727: every value-flavoured local has only a single assignment and many 1728: advantages of functional languages apply to Forth. I.e., programs are 1729: easier to analyse, to optimize and to read: It is clear from the 1730: definition what the local stands for, it does not turn into something 1731: different later. 1732: 1733: E.g., a definition using @code{TO} might look like this: 1734: @example 1735: : strcmp @{ addr1 u1 addr2 u2 -- n @} 1736: u1 u2 min 0 1737: ?do 1738: addr1 c@ addr2 c@ - ?dup 1739: if 1740: unloop exit 1741: then 1742: addr1 char+ TO addr1 1743: addr2 char+ TO addr2 1744: loop 1745: u1 u2 - ; 1746: @end example 1747: Here, @code{TO} is used to update @code{addr1} and @code{addr2} at 1748: every loop iteration. @code{strcmp} is a typical example of the 1749: readability problems of using @code{TO}. When you start reading 1750: @code{strcmp}, you think that @code{addr1} refers to the start of the 1751: string. Only near the end of the loop you realize that it is something 1752: else. 1753: 1754: This can be avoided by defining two locals at the start of the loop that 1755: are initialized with the right value for the current iteration. 1756: @example 1757: : strcmp @{ addr1 u1 addr2 u2 -- n @} 1758: addr1 addr2 1759: u1 u2 min 0 1760: ?do @{ s1 s2 @} 1761: s1 c@ s2 c@ - ?dup 1762: if 1763: unloop exit 1764: then 1765: s1 char+ s2 char+ 1766: loop 1767: 2drop 1768: u1 u2 - ; 1769: @end example 1770: Here it is clear from the start that @code{s1} has a different value 1771: in every loop iteration. 1772: 1.17 anton 1773: @node Implementation, , Programming Style, Gforth locals 1.2 anton 1774: @subsubsection Implementation 1775: 1.17 anton 1776: Gforth uses an extra locals stack. The most compelling reason for 1.2 anton 1777: this is that the return stack is not float-aligned; using an extra stack 1778: also eliminates the problems and restrictions of using the return stack 1779: as locals stack. Like the other stacks, the locals stack grows toward 1780: lower addresses. A few primitives allow an efficient implementation: 1781: 1782: doc-@local# 1783: doc-f@local# 1784: doc-laddr# 1785: doc-lp+!# 1786: doc-lp! 1787: doc->l 1788: doc-f>l 1789: 1790: In addition to these primitives, some specializations of these 1791: primitives for commonly occurring inline arguments are provided for 1792: efficiency reasons, e.g., @code{@@local0} as specialization of 1793: @code{@@local#} for the inline argument 0. The following compiling words 1794: compile the right specialized version, or the general version, as 1795: appropriate: 1796: 1.12 anton 1797: doc-compile-@local 1798: doc-compile-f@local 1.2 anton 1799: doc-compile-lp+! 1800: 1801: Combinations of conditional branches and @code{lp+!#} like 1802: @code{?branch-lp+!#} (the locals pointer is only changed if the branch 1803: is taken) are provided for efficiency and correctness in loops. 1804: 1805: A special area in the dictionary space is reserved for keeping the 1806: local variable names. @code{@{} switches the dictionary pointer to this 1807: area and @code{@}} switches it back and generates the locals 1808: initializing code. @code{W:} etc.@ are normal defining words. This 1809: special area is cleared at the start of every colon definition. 1810: 1.17 anton 1811: A special feature of Gforth's dictionary is used to implement the 1.2 anton 1812: definition of locals without type specifiers: every wordlist (aka 1813: vocabulary) has its own methods for searching 1.4 anton 1814: etc. (@pxref{Wordlists}). For the present purpose we defined a wordlist 1.2 anton 1815: with a special search method: When it is searched for a word, it 1816: actually creates that word using @code{W:}. @code{@{} changes the search 1817: order to first search the wordlist containing @code{@}}, @code{W:} etc., 1818: and then the wordlist for defining locals without type specifiers. 1819: 1820: The lifetime rules support a stack discipline within a colon 1821: definition: The lifetime of a local is either nested with other locals 1822: lifetimes or it does not overlap them. 1823: 1824: At @code{BEGIN}, @code{IF}, and @code{AHEAD} no code for locals stack 1825: pointer manipulation is generated. Between control structure words 1826: locals definitions can push locals onto the locals stack. @code{AGAIN} 1827: is the simplest of the other three control flow words. It has to 1828: restore the locals stack depth of the corresponding @code{BEGIN} 1829: before branching. The code looks like this: 1830: @format 1831: @code{lp+!#} current-locals-size @minus{} dest-locals-size 1832: @code{branch} <begin> 1833: @end format 1834: 1835: @code{UNTIL} is a little more complicated: If it branches back, it 1836: must adjust the stack just like @code{AGAIN}. But if it falls through, 1837: the locals stack must not be changed. The compiler generates the 1838: following code: 1839: @format 1840: @code{?branch-lp+!#} <begin> current-locals-size @minus{} dest-locals-size 1841: @end format 1842: The locals stack pointer is only adjusted if the branch is taken. 1843: 1844: @code{THEN} can produce somewhat inefficient code: 1845: @format 1846: @code{lp+!#} current-locals-size @minus{} orig-locals-size 1847: <orig target>: 1848: @code{lp+!#} orig-locals-size @minus{} new-locals-size 1849: @end format 1850: The second @code{lp+!#} adjusts the locals stack pointer from the 1.4 anton 1851: level at the @var{orig} point to the level after the @code{THEN}. The 1.2 anton 1852: first @code{lp+!#} adjusts the locals stack pointer from the current 1853: level to the level at the orig point, so the complete effect is an 1854: adjustment from the current level to the right level after the 1855: @code{THEN}. 1856: 1857: In a conventional Forth implementation a dest control-flow stack entry 1858: is just the target address and an orig entry is just the address to be 1859: patched. Our locals implementation adds a wordlist to every orig or dest 1860: item. It is the list of locals visible (or assumed visible) at the point 1861: described by the entry. Our implementation also adds a tag to identify 1862: the kind of entry, in particular to differentiate between live and dead 1863: (reachable and unreachable) orig entries. 1864: 1865: A few unusual operations have to be performed on locals wordlists: 1866: 1867: doc-common-list 1868: doc-sub-list? 1869: doc-list-size 1870: 1871: Several features of our locals wordlist implementation make these 1872: operations easy to implement: The locals wordlists are organised as 1873: linked lists; the tails of these lists are shared, if the lists 1874: contain some of the same locals; and the address of a name is greater 1875: than the address of the names behind it in the list. 1876: 1877: Another important implementation detail is the variable 1878: @code{dead-code}. It is used by @code{BEGIN} and @code{THEN} to 1879: determine if they can be reached directly or only through the branch 1880: that they resolve. @code{dead-code} is set by @code{UNREACHABLE}, 1881: @code{AHEAD}, @code{EXIT} etc., and cleared at the start of a colon 1882: definition, by @code{BEGIN} and usually by @code{THEN}. 1883: 1884: Counted loops are similar to other loops in most respects, but 1885: @code{LEAVE} requires special attention: It performs basically the same 1886: service as @code{AHEAD}, but it does not create a control-flow stack 1887: entry. Therefore the information has to be stored elsewhere; 1888: traditionally, the information was stored in the target fields of the 1889: branches created by the @code{LEAVE}s, by organizing these fields into a 1890: linked list. Unfortunately, this clever trick does not provide enough 1891: space for storing our extended control flow information. Therefore, we 1892: introduce another stack, the leave stack. It contains the control-flow 1893: stack entries for all unresolved @code{LEAVE}s. 1894: 1895: Local names are kept until the end of the colon definition, even if 1896: they are no longer visible in any control-flow path. In a few cases 1897: this may lead to increased space needs for the locals name area, but 1898: usually less than reclaiming this space would cost in code size. 1899: 1900: 1.17 anton 1901: @node ANS Forth locals, , Gforth locals, Locals 1.2 anton 1902: @subsection ANS Forth locals 1903: 1904: The ANS Forth locals wordset does not define a syntax for locals, but 1905: words that make it possible to define various syntaxes. One of the 1.17 anton 1906: possible syntaxes is a subset of the syntax we used in the Gforth locals 1.2 anton 1907: wordset, i.e.: 1908: 1909: @example 1910: @{ local1 local2 ... -- comment @} 1911: @end example 1912: or 1913: @example 1914: @{ local1 local2 ... @} 1915: @end example 1916: 1917: The order of the locals corresponds to the order in a stack comment. The 1918: restrictions are: 1.1 anton 1919: 1.2 anton 1920: @itemize @bullet 1921: @item 1.17 anton 1922: Locals can only be cell-sized values (no type specifiers are allowed). 1.2 anton 1923: @item 1924: Locals can be defined only outside control structures. 1925: @item 1926: Locals can interfere with explicit usage of the return stack. For the 1927: exact (and long) rules, see the standard. If you don't use return stack 1.17 anton 1928: accessing words in a definition using locals, you will be all right. The 1.2 anton 1929: purpose of this rule is to make locals implementation on the return 1930: stack easier. 1931: @item 1932: The whole definition must be in one line. 1933: @end itemize 1934: 1935: Locals defined in this way behave like @code{VALUE}s 1.4 anton 1936: (@xref{Values}). I.e., they are initialized from the stack. Using their 1.2 anton 1937: name produces their value. Their value can be changed using @code{TO}. 1938: 1.17 anton 1939: Since this syntax is supported by Gforth directly, you need not do 1.2 anton 1940: anything to use it. If you want to port a program using this syntax to 1941: another ANS Forth system, use @file{anslocal.fs} to implement the syntax 1942: on the other system. 1943: 1944: Note that a syntax shown in the standard, section A.13 looks 1945: similar, but is quite different in having the order of locals 1946: reversed. Beware! 1947: 1948: The ANS Forth locals wordset itself consists of the following word 1949: 1950: doc-(local) 1951: 1952: The ANS Forth locals extension wordset defines a syntax, but it is so 1953: awful that we strongly recommend not to use it. We have implemented this 1.17 anton 1954: syntax to make porting to Gforth easy, but do not document it here. The 1.2 anton 1955: problem with this syntax is that the locals are defined in an order 1956: reversed with respect to the standard stack comment notation, making 1957: programs harder to read, and easier to misread and miswrite. The only 1958: merit of this syntax is that it is easy to implement using the ANS Forth 1959: locals wordset. 1.3 anton 1960: 1.4 anton 1961: @node Defining Words, Wordlists, Locals, Words 1962: @section Defining Words 1963: 1.14 anton 1964: @menu 1965: * Values:: 1966: @end menu 1967: 1.4 anton 1968: @node Values, , Defining Words, Defining Words 1969: @subsection Values 1970: 1971: @node Wordlists, Files, Defining Words, Words 1972: @section Wordlists 1973: 1974: @node Files, Blocks, Wordlists, Words 1975: @section Files 1976: 1977: @node Blocks, Other I/O, Files, Words 1978: @section Blocks 1979: 1980: @node Other I/O, Programming Tools, Blocks, Words 1981: @section Other I/O 1982: 1.18 anton 1983: @node Programming Tools, Assembler and Code words, Other I/O, Words 1.4 anton 1984: @section Programming Tools 1985: 1.5 anton 1986: @menu 1987: * Debugging:: Simple and quick. 1988: * Assertions:: Making your programs self-checking. 1989: @end menu 1990: 1991: @node Debugging, Assertions, Programming Tools, Programming Tools 1.4 anton 1992: @subsection Debugging 1993: 1994: The simple debugging aids provided in @file{debugging.fs} 1995: are meant to support a different style of debugging than the 1996: tracing/stepping debuggers used in languages with long turn-around 1997: times. 1998: 1999: A much better (faster) way in fast-compilig languages is to add 2000: printing code at well-selected places, let the program run, look at 2001: the output, see where things went wrong, add more printing code, etc., 2002: until the bug is found. 2003: 2004: The word @code{~~} is easy to insert. It just prints debugging 2005: information (by default the source location and the stack contents). It 2006: is also easy to remove (@kbd{C-x ~} in the Emacs Forth mode to 2007: query-replace them with nothing). The deferred words 2008: @code{printdebugdata} and @code{printdebugline} control the output of 2009: @code{~~}. The default source location output format works well with 2010: Emacs' compilation mode, so you can step through the program at the 1.5 anton 2011: source level using @kbd{C-x `} (the advantage over a stepping debugger 2012: is that you can step in any direction and you know where the crash has 2013: happened or where the strange data has occurred). 1.4 anton 2014: 2015: Note that the default actions clobber the contents of the pictured 2016: numeric output string, so you should not use @code{~~}, e.g., between 2017: @code{<#} and @code{#>}. 2018: 2019: doc-~~ 2020: doc-printdebugdata 2021: doc-printdebugline 2022: 1.5 anton 2023: @node Assertions, , Debugging, Programming Tools 1.4 anton 2024: @subsection Assertions 2025: 1.5 anton 2026: It is a good idea to make your programs self-checking, in particular, if 2027: you use an assumption (e.g., that a certain field of a data structure is 1.17 anton 2028: never zero) that may become wrong during maintenance. Gforth supports 1.5 anton 2029: assertions for this purpose. They are used like this: 2030: 2031: @example 2032: assert( @var{flag} ) 2033: @end example 2034: 2035: The code between @code{assert(} and @code{)} should compute a flag, that 2036: should be true if everything is alright and false otherwise. It should 2037: not change anything else on the stack. The overall stack effect of the 2038: assertion is @code{( -- )}. E.g. 2039: 2040: @example 2041: assert( 1 1 + 2 = ) \ what we learn in school 2042: assert( dup 0<> ) \ assert that the top of stack is not zero 2043: assert( false ) \ this code should not be reached 2044: @end example 2045: 2046: The need for assertions is different at different times. During 2047: debugging, we want more checking, in production we sometimes care more 2048: for speed. Therefore, assertions can be turned off, i.e., the assertion 2049: becomes a comment. Depending on the importance of an assertion and the 2050: time it takes to check it, you may want to turn off some assertions and 1.17 anton 2051: keep others turned on. Gforth provides several levels of assertions for 1.5 anton 2052: this purpose: 2053: 2054: doc-assert0( 2055: doc-assert1( 2056: doc-assert2( 2057: doc-assert3( 2058: doc-assert( 2059: doc-) 2060: 2061: @code{Assert(} is the same as @code{assert1(}. The variable 2062: @code{assert-level} specifies the highest assertions that are turned 2063: on. I.e., at the default @code{assert-level} of one, @code{assert0(} and 2064: @code{assert1(} assertions perform checking, while @code{assert2(} and 2065: @code{assert3(} assertions are treated as comments. 2066: 2067: Note that the @code{assert-level} is evaluated at compile-time, not at 2068: run-time. I.e., you cannot turn assertions on or off at run-time, you 2069: have to set the @code{assert-level} appropriately before compiling a 2070: piece of code. You can compile several pieces of code at several 2071: @code{assert-level}s (e.g., a trusted library at level 1 and newly 2072: written code at level 3). 2073: 2074: doc-assert-level 2075: 2076: If an assertion fails, a message compatible with Emacs' compilation mode 2077: is produced and the execution is aborted (currently with @code{ABORT"}. 2078: If there is interest, we will introduce a special throw code. But if you 2079: intend to @code{catch} a specific condition, using @code{throw} is 2080: probably more appropriate than an assertion). 2081: 1.18 anton 2082: @node Assembler and Code words, Threading Words, Programming Tools, Words 2083: @section Assembler and Code words 2084: 2085: Gforth provides some words for defining primitives (words written in 2086: machine code), and for defining the the machine-code equivalent of 2087: @code{DOES>}-based defining words. However, the machine-independent 2088: nature of Gforth poses a few problems: First of all. Gforth runs on 2089: several architectures, so it can provide no standard assembler. What's 2090: worse is that the register allocation not only depends on the processor, 2091: but also on the gcc version and options used. 2092: 2093: The words Gforth offers encapsulate some system dependences (e.g., the 2094: header structure), so a system-independent assembler may be used in 2095: Gforth. If you do not have an assembler, you can compile machine code 2096: directly with @code{,} and @code{c,}. 2097: 2098: doc-assembler 2099: doc-code 2100: doc-end-code 2101: doc-;code 2102: doc-flush-icache 2103: 2104: If @code{flush-icache} does not work correctly, @code{code} words 2105: etc. will not work (reliably), either. 2106: 2107: These words are rarely used. Therefore they reside in @code{code.fs}, 2108: which is usually not loaded (except @code{flush-icache}, which is always 1.19 anton 2109: present). You can load them with @code{require code.fs}. 1.18 anton 2110: 2111: Another option for implementing normal and defining words efficiently 2112: is: adding the wanted functionality to the source of Gforth. For normal 2113: words you just have to edit @file{primitives}, defining words (for fast 2114: defined words) probably require changes in @file{engine.c}, 2115: @file{kernal.fs}, @file{prims2x.fs}, and possibly @file{cross.fs}. 2116: 2117: 2118: @node Threading Words, , Assembler and Code words, Words 1.4 anton 2119: @section Threading Words 2120: 2121: These words provide access to code addresses and other threading stuff 1.17 anton 2122: in Gforth (and, possibly, other interpretive Forths). It more or less 1.4 anton 2123: abstracts away the differences between direct and indirect threading 2124: (and, for direct threading, the machine dependences). However, at 2125: present this wordset is still inclomplete. It is also pretty low-level; 2126: some day it will hopefully be made unnecessary by an internals words set 2127: that abstracts implementation details away completely. 2128: 2129: doc->code-address 2130: doc->does-code 2131: doc-code-address! 2132: doc-does-code! 2133: doc-does-handler! 2134: doc-/does-handler 2135: 1.18 anton 2136: The code addresses produced by various defining words are produced by 2137: the following words: 1.14 anton 2138: 1.18 anton 2139: doc-docol: 2140: doc-docon: 2141: doc-dovar: 2142: doc-douser: 2143: doc-dodefer: 2144: doc-dofield: 2145: 2146: Currently there is no installation-independent way for recogizing words 2147: defined by a @code{CREATE}...@code{DOES>} word; however, once you know 2148: that a word is defined by a @code{CREATE}...@code{DOES>} word, you can 2149: use @code{>DOES-CODE}. 1.14 anton 2150: 1.4 anton 2151: @node ANS conformance, Model, Words, Top 2152: @chapter ANS conformance 2153: 1.17 anton 2154: To the best of our knowledge, Gforth is an 1.14 anton 2155: 1.15 anton 2156: ANS Forth System 2157: @itemize 2158: @item providing the Core Extensions word set 2159: @item providing the Block word set 2160: @item providing the Block Extensions word set 2161: @item providing the Double-Number word set 2162: @item providing the Double-Number Extensions word set 2163: @item providing the Exception word set 2164: @item providing the Exception Extensions word set 2165: @item providing the Facility word set 2166: @item providing @code{MS} and @code{TIME&DATE} from the Facility Extensions word set 2167: @item providing the File Access word set 2168: @item providing the File Access Extensions word set 2169: @item providing the Floating-Point word set 2170: @item providing the Floating-Point Extensions word set 2171: @item providing the Locals word set 2172: @item providing the Locals Extensions word set 2173: @item providing the Memory-Allocation word set 2174: @item providing the Memory-Allocation Extensions word set (that one's easy) 2175: @item providing the Programming-Tools word set 1.18 anton 2176: @item providing @code{;code}, @code{AHEAD}, @code{ASSEMBLER}, @code{BYE}, @code{CODE}, @code{CS-PICK}, @code{CS-ROLL}, @code{STATE}, @code{[ELSE]}, @code{[IF]}, @code{[THEN]} from the Programming-Tools Extensions word set 1.15 anton 2177: @item providing the Search-Order word set 2178: @item providing the Search-Order Extensions word set 2179: @item providing the String word set 2180: @item providing the String Extensions word set (another easy one) 2181: @end itemize 2182: 2183: In addition, ANS Forth systems are required to document certain 2184: implementation choices. This chapter tries to meet these 2185: requirements. In many cases it gives a way to ask the system for the 2186: information instead of providing the information directly, in 2187: particular, if the information depends on the processor, the operating 2188: system or the installation options chosen, or if they are likely to 1.17 anton 2189: change during the maintenance of Gforth. 1.15 anton 2190: 1.14 anton 2191: @comment The framework for the rest has been taken from pfe. 2192: 2193: @menu 2194: * The Core Words:: 2195: * The optional Block word set:: 2196: * The optional Double Number word set:: 2197: * The optional Exception word set:: 2198: * The optional Facility word set:: 2199: * The optional File-Access word set:: 2200: * The optional Floating-Point word set:: 2201: * The optional Locals word set:: 2202: * The optional Memory-Allocation word set:: 2203: * The optional Programming-Tools word set:: 2204: * The optional Search-Order word set:: 2205: @end menu 2206: 2207: 2208: @c ===================================================================== 2209: @node The Core Words, The optional Block word set, ANS conformance, ANS conformance 2210: @comment node-name, next, previous, up 2211: @section The Core Words 2212: @c ===================================================================== 2213: 2214: @menu 1.15 anton 2215: * core-idef:: Implementation Defined Options 2216: * core-ambcond:: Ambiguous Conditions 2217: * core-other:: Other System Documentation 1.14 anton 2218: @end menu 2219: 2220: @c --------------------------------------------------------------------- 2221: @node core-idef, core-ambcond, The Core Words, The Core Words 2222: @subsection Implementation Defined Options 2223: @c --------------------------------------------------------------------- 2224: 2225: @table @i 2226: 2227: @item (Cell) aligned addresses: 1.17 anton 2228: processor-dependent. Gforth's alignment words perform natural alignment 1.14 anton 2229: (e.g., an address aligned for a datum of size 8 is divisible by 2230: 8). Unaligned accesses usually result in a @code{-23 THROW}. 2231: 2232: @item @code{EMIT} and non-graphic characters: 2233: The character is output using the C library function (actually, macro) 2234: @code{putchar}. 2235: 2236: @item character editing of @code{ACCEPT} and @code{EXPECT}: 2237: This is modeled on the GNU readline library (@pxref{Readline 2238: Interaction, , Command Line Editing, readline, The GNU Readline 2239: Library}) with Emacs-like key bindings. @kbd{Tab} deviates a little by 2240: producing a full word completion every time you type it (instead of 2241: producing the common prefix of all completions). 2242: 2243: @item character set: 2244: The character set of your computer and display device. Gforth is 2245: 8-bit-clean (but some other component in your system may make trouble). 2246: 2247: @item Character-aligned address requirements: 2248: installation-dependent. Currently a character is represented by a C 2249: @code{unsigned char}; in the future we might switch to @code{wchar_t} 2250: (Comments on that requested). 2251: 2252: @item character-set extensions and matching of names: 1.17 anton 2253: Any character except the ASCII NUL charcter can be used in a 2254: name. Matching is case-insensitive. The matching is performed using the 2255: C function @code{strncasecmp}, whose function is probably influenced by 2256: the locale. E.g., the @code{C} locale does not know about accents and 1.14 anton 2257: umlauts, so they are matched case-sensitively in that locale. For 2258: portability reasons it is best to write programs such that they work in 2259: the @code{C} locale. Then one can use libraries written by a Polish 2260: programmer (who might use words containing ISO Latin-2 encoded 2261: characters) and by a French programmer (ISO Latin-1) in the same program 2262: (of course, @code{WORDS} will produce funny results for some of the 2263: words (which ones, depends on the font you are using)). Also, the locale 2264: you prefer may not be available in other operating systems. Hopefully, 2265: Unicode will solve these problems one day. 2266: 2267: @item conditions under which control characters match a space delimiter: 2268: If @code{WORD} is called with the space character as a delimiter, all 2269: white-space characters (as identified by the C macro @code{isspace()}) 2270: are delimiters. @code{PARSE}, on the other hand, treats space like other 2271: delimiters. @code{PARSE-WORD} treats space like @code{WORD}, but behaves 2272: like @code{PARSE} otherwise. @code{(NAME)}, which is used by the outer 2273: interpreter (aka text interpreter) by default, treats all white-space 2274: characters as delimiters. 2275: 2276: @item format of the control flow stack: 2277: The data stack is used as control flow stack. The size of a control flow 2278: stack item in cells is given by the constant @code{cs-item-size}. At the 2279: time of this writing, an item consists of a (pointer to a) locals list 2280: (third), an address in the code (second), and a tag for identifying the 2281: item (TOS). The following tags are used: @code{defstart}, 2282: @code{live-orig}, @code{dead-orig}, @code{dest}, @code{do-dest}, 2283: @code{scopestart}. 2284: 2285: @item conversion of digits > 35 2286: The characters @code{[\]^_'} are the digits with the decimal value 2287: 36@minus{}41. There is no way to input many of the larger digits. 2288: 2289: @item display after input terminates in @code{ACCEPT} and @code{EXPECT}: 2290: The cursor is moved to the end of the entered string. If the input is 2291: terminated using the @kbd{Return} key, a space is typed. 2292: 2293: @item exception abort sequence of @code{ABORT"}: 2294: The error string is stored into the variable @code{"error} and a 2295: @code{-2 throw} is performed. 2296: 2297: @item input line terminator: 2298: For interactive input, @kbd{C-m} and @kbd{C-j} terminate lines. One of 2299: these characters is typically produced when you type the @kbd{Enter} or 2300: @kbd{Return} key. 2301: 2302: @item maximum size of a counted string: 2303: @code{s" /counted-string" environment? drop .}. Currently 255 characters 2304: on all ports, but this may change. 2305: 2306: @item maximum size of a parsed string: 2307: Given by the constant @code{/line}. Currently 255 characters. 2308: 2309: @item maximum size of a definition name, in characters: 2310: 31 2311: 2312: @item maximum string length for @code{ENVIRONMENT?}, in characters: 2313: 31 2314: 2315: @item method of selecting the user input device: 1.17 anton 2316: The user input device is the standard input. There is currently no way to 2317: change it from within Gforth. However, the input can typically be 2318: redirected in the command line that starts Gforth. 1.14 anton 2319: 2320: @item method of selecting the user output device: 2321: The user output device is the standard output. It cannot be redirected 1.17 anton 2322: from within Gforth, but typically from the command line that starts 2323: Gforth. Gforth uses buffered output, so output on a terminal does not 1.14 anton 2324: become visible before the next newline or buffer overflow. Output on 2325: non-terminals is invisible until the buffer overflows. 2326: 2327: @item methods of dictionary compilation: 1.17 anton 2328: What are we expected to document here? 1.14 anton 2329: 2330: @item number of bits in one address unit: 2331: @code{s" address-units-bits" environment? drop .}. 8 in all current 2332: ports. 2333: 2334: @item number representation and arithmetic: 2335: Processor-dependent. Binary two's complement on all current ports. 2336: 2337: @item ranges for integer types: 2338: Installation-dependent. Make environmental queries for @code{MAX-N}, 2339: @code{MAX-U}, @code{MAX-D} and @code{MAX-UD}. The lower bounds for 2340: unsigned (and positive) types is 0. The lower bound for signed types on 2341: two's complement and one's complement machines machines can be computed 2342: by adding 1 to the upper bound. 2343: 2344: @item read-only data space regions: 2345: The whole Forth data space is writable. 2346: 2347: @item size of buffer at @code{WORD}: 2348: @code{PAD HERE - .}. 104 characters on 32-bit machines. The buffer is 2349: shared with the pictured numeric output string. If overwriting 2350: @code{PAD} is acceptable, it is as large as the remaining dictionary 2351: space, although only as much can be sensibly used as fits in a counted 2352: string. 2353: 2354: @item size of one cell in address units: 2355: @code{1 cells .}. 2356: 2357: @item size of one character in address units: 2358: @code{1 chars .}. 1 on all current ports. 2359: 2360: @item size of the keyboard terminal buffer: 2361: Varies. You can determine the size at a specific time using @code{lp@ 2362: tib - .}. It is shared with the locals stack and TIBs of files that 2363: include the current file. You can change the amount of space for TIBs 1.17 anton 2364: and locals stack at Gforth startup with the command line option 1.14 anton 2365: @code{-l}. 2366: 2367: @item size of the pictured numeric output buffer: 2368: @code{PAD HERE - .}. 104 characters on 32-bit machines. The buffer is 2369: shared with @code{WORD}. 2370: 2371: @item size of the scratch area returned by @code{PAD}: 2372: The remainder of dictionary space. You can even use the unused part of 2373: the data stack space. The current size can be computed with @code{sp@ 2374: pad - .}. 2375: 2376: @item system case-sensitivity characteristics: 2377: Dictionary searches are case insensitive. However, as explained above 2378: under @i{character-set extensions}, the matching for non-ASCII 2379: characters is determined by the locale you are using. In the default 2380: @code{C} locale all non-ASCII characters are matched case-sensitively. 2381: 2382: @item system prompt: 2383: @code{ ok} in interpret state, @code{ compiled} in compile state. 2384: 2385: @item division rounding: 2386: installation dependent. @code{s" floored" environment? drop .}. We leave 2387: the choice to gcc (what to use for @code{/}) and to you (whether to use 2388: @code{fm/mod}, @code{sm/rem} or simply @code{/}). 2389: 2390: @item values of @code{STATE} when true: 2391: -1. 2392: 2393: @item values returned after arithmetic overflow: 2394: On two's complement machines, arithmetic is performed modulo 2395: 2**bits-per-cell for single arithmetic and 4**bits-per-cell for double 2396: arithmetic (with appropriate mapping for signed types). Division by zero 2397: typically results in a @code{-55 throw} (floatingpoint unidentified 2398: fault), although a @code{-10 throw} (divide by zero) would be more 2399: appropriate. 2400: 2401: @item whether the current definition can be found after @t{DOES>}: 2402: No. 2403: 2404: @end table 2405: 2406: @c --------------------------------------------------------------------- 2407: @node core-ambcond, core-other, core-idef, The Core Words 2408: @subsection Ambiguous conditions 2409: @c --------------------------------------------------------------------- 2410: 2411: @table @i 2412: 2413: @item a name is neither a word nor a number: 2414: @code{-13 throw} (Undefined word) 2415: 2416: @item a definition name exceeds the maximum length allowed: 2417: @code{-19 throw} (Word name too long) 2418: 2419: @item addressing a region not inside the various data spaces of the forth system: 2420: The stacks, code space and name space are accessible. Machine code space is 2421: typically readable. Accessing other addresses gives results dependent on 2422: the operating system. On decent systems: @code{-9 throw} (Invalid memory 2423: address). 2424: 2425: @item argument type incompatible with parameter: 2426: This is usually not caught. Some words perform checks, e.g., the control 2427: flow words, and issue a @code{ABORT"} or @code{-12 THROW} (Argument type 2428: mismatch). 2429: 2430: @item attempting to obtain the execution token of a word with undefined execution semantics: 2431: You get an execution token representing the compilation semantics 2432: instead. 2433: 2434: @item dividing by zero: 2435: typically results in a @code{-55 throw} (floating point unidentified 2436: fault), although a @code{-10 throw} (divide by zero) would be more 2437: appropriate. 2438: 2439: @item insufficient data stack or return stack space: 2440: Not checked. This typically results in mysterious illegal memory 2441: accesses, producing @code{-9 throw} (Invalid memory address) or 2442: @code{-23 throw} (Address alignment exception). 2443: 2444: @item insufficient space for loop control parameters: 2445: like other return stack overflows. 2446: 2447: @item insufficient space in the dictionary: 2448: Not checked. Similar results as stack overflows. However, typically the 2449: error appears at a different place when one inserts or removes code. 2450: 2451: @item interpreting a word with undefined interpretation semantics: 2452: For some words, we defined interpretation semantics. For the others: 2453: @code{-14 throw} (Interpreting a compile-only word). Note that this is 2454: checked only by the outer (aka text) interpreter; if the word is 2455: @code{execute}d in some other way, it will typically perform it's 2456: compilation semantics even in interpret state. (We could change @code{'} 2457: and relatives not to give the xt of such words, but we think that would 2458: be too restrictive). 2459: 2460: @item modifying the contents of the input buffer or a string literal: 2461: These are located in writable memory and can be modified. 2462: 2463: @item overflow of the pictured numeric output string: 2464: Not checked. 2465: 2466: @item parsed string overflow: 2467: @code{PARSE} cannot overflow. @code{WORD} does not check for overflow. 2468: 2469: @item producing a result out of range: 2470: On two's complement machines, arithmetic is performed modulo 2471: 2**bits-per-cell for single arithmetic and 4**bits-per-cell for double 2472: arithmetic (with appropriate mapping for signed types). Division by zero 2473: typically results in a @code{-55 throw} (floatingpoint unidentified 2474: fault), although a @code{-10 throw} (divide by zero) would be more 2475: appropriate. @code{convert} and @code{>number} currently overflow 2476: silently. 2477: 2478: @item reading from an empty data or return stack: 2479: The data stack is checked by the outer (aka text) interpreter after 2480: every word executed. If it has underflowed, a @code{-4 throw} (Stack 2481: underflow) is performed. Apart from that, the stacks are not checked and 2482: underflows can result in similar behaviour as overflows (of adjacent 2483: stacks). 2484: 2485: @item unexepected end of the input buffer, resulting in an attempt to use a zero-length string as a name: 2486: @code{Create} and its descendants perform a @code{-16 throw} (Attempt to 2487: use zero-length string as a name). Words like @code{'} probably will not 2488: find what they search. Note that it is possible to create zero-length 2489: names with @code{nextname} (should it not?). 2490: 2491: @item @code{>IN} greater than input buffer: 2492: The next invocation of a parsing word returns a string wih length 0. 2493: 2494: @item @code{RECURSE} appears after @code{DOES>}: 2495: Compiles a recursive call to the defining word not to the defined word. 2496: 2497: @item argument input source different than current input source for @code{RESTORE-INPUT}: 2498: !!???If the argument input source is a valid input source then it gets 1.19 anton 2499: restored. Otherwise causes @code{-12 THROW}, which, unless caught, issues 1.14 anton 2500: the message "argument type mismatch" and aborts. 2501: 2502: @item data space containing definitions gets de-allocated: 2503: Deallocation with @code{allot} is not checked. This typically resuls in 2504: memory access faults or execution of illegal instructions. 2505: 2506: @item data space read/write with incorrect alignment: 2507: Processor-dependent. Typically results in a @code{-23 throw} (Address 2508: alignment exception). Under Linux on a 486 or later processor with 2509: alignment turned on, incorrect alignment results in a @code{-9 throw} 2510: (Invalid memory address). There are reportedly some processors with 2511: alignment restrictions that do not report them. 2512: 2513: @item data space pointer not properly aligned, @code{,}, @code{C,}: 2514: Like other alignment errors. 2515: 2516: @item less than u+2 stack items (@code{PICK} and @code{ROLL}): 2517: Not checked. May cause an illegal memory access. 2518: 2519: @item loop control parameters not available: 2520: Not checked. The counted loop words simply assume that the top of return 2521: stack items are loop control parameters and behave accordingly. 2522: 2523: @item most recent definition does not have a name (@code{IMMEDIATE}): 2524: @code{abort" last word was headerless"}. 2525: 2526: @item name not defined by @code{VALUE} used by @code{TO}: 2527: @code{-32 throw} (Invalid name argument) 2528: 1.15 anton 2529: @item name not found (@code{'}, @code{POSTPONE}, @code{[']}, @code{[COMPILE]}): 1.14 anton 2530: @code{-13 throw} (Undefined word) 2531: 2532: @item parameters are not of the same type (@code{DO}, @code{?DO}, @code{WITHIN}): 2533: Gforth behaves as if they were of the same type. I.e., you can predict 2534: the behaviour by interpreting all parameters as, e.g., signed. 2535: 2536: @item @code{POSTPONE} or @code{[COMPILE]} applied to @code{TO}: 2537: Assume @code{: X POSTPONE TO ; IMMEDIATE}. @code{X} is equivalent to 2538: @code{TO}. 2539: 2540: @item String longer than a counted string returned by @code{WORD}: 2541: Not checked. The string will be ok, but the count will, of course, 2542: contain only the least significant bits of the length. 2543: 1.15 anton 2544: @item u greater than or equal to the number of bits in a cell (@code{LSHIFT}, @code{RSHIFT}): 1.14 anton 2545: Processor-dependent. Typical behaviours are returning 0 and using only 2546: the low bits of the shift count. 2547: 2548: @item word not defined via @code{CREATE}: 2549: @code{>BODY} produces the PFA of the word no matter how it was defined. 2550: 2551: @code{DOES>} changes the execution semantics of the last defined word no 2552: matter how it was defined. E.g., @code{CONSTANT DOES>} is equivalent to 2553: @code{CREATE , DOES>}. 2554: 2555: @item words improperly used outside @code{<#} and @code{#>}: 2556: Not checked. As usual, you can expect memory faults. 2557: 2558: @end table 2559: 2560: 2561: @c --------------------------------------------------------------------- 2562: @node core-other, , core-ambcond, The Core Words 2563: @subsection Other system documentation 2564: @c --------------------------------------------------------------------- 2565: 2566: @table @i 2567: 2568: @item nonstandard words using @code{PAD}: 2569: None. 2570: 2571: @item operator's terminal facilities available: 2572: !!?? 2573: 2574: @item program data space available: 2575: @code{sp@ here - .} gives the space remaining for dictionary and data 2576: stack together. 2577: 2578: @item return stack space available: 2579: !!?? 2580: 2581: @item stack space available: 2582: @code{sp@ here - .} gives the space remaining for dictionary and data 2583: stack together. 2584: 2585: @item system dictionary space required, in address units: 2586: Type @code{here forthstart - .} after startup. At the time of this 2587: writing, this gives 70108 (bytes) on a 32-bit system. 2588: @end table 2589: 2590: 2591: @c ===================================================================== 2592: @node The optional Block word set, The optional Double Number word set, The Core Words, ANS conformance 2593: @section The optional Block word set 2594: @c ===================================================================== 2595: 2596: @menu 1.15 anton 2597: * block-idef:: Implementation Defined Options 2598: * block-ambcond:: Ambiguous Conditions 2599: * block-other:: Other System Documentation 1.14 anton 2600: @end menu 2601: 2602: 2603: @c --------------------------------------------------------------------- 2604: @node block-idef, block-ambcond, The optional Block word set, The optional Block word set 2605: @subsection Implementation Defined Options 2606: @c --------------------------------------------------------------------- 2607: 2608: @table @i 2609: 2610: @item the format for display by @code{LIST}: 2611: First the screen number is displayed, then 16 lines of 64 characters, 2612: each line preceded by the line number. 2613: 2614: @item the length of a line affected by @code{\}: 2615: 64 characters. 2616: @end table 2617: 2618: 2619: @c --------------------------------------------------------------------- 2620: @node block-ambcond, block-other, block-idef, The optional Block word set 2621: @subsection Ambiguous conditions 2622: @c --------------------------------------------------------------------- 2623: 2624: @table @i 2625: 2626: @item correct block read was not possible: 2627: Typically results in a @code{throw} of some OS-derived value (between 2628: -512 and -2048). If the blocks file was just not long enough, blanks are 2629: supplied for the missing portion. 2630: 2631: @item I/O exception in block transfer: 2632: Typically results in a @code{throw} of some OS-derived value (between 2633: -512 and -2048). 2634: 2635: @item invalid block number: 2636: @code{-35 throw} (Invalid block number) 2637: 2638: @item a program directly alters the contents of @code{BLK}: 2639: The input stream is switched to that other block, at the same 2640: position. If the storing to @code{BLK} happens when interpreting 2641: non-block input, the system will get quite confused when the block ends. 2642: 2643: @item no current block buffer for @code{UPDATE}: 2644: @code{UPDATE} has no effect. 2645: 2646: @end table 2647: 2648: 2649: @c --------------------------------------------------------------------- 2650: @node block-other, , block-ambcond, The optional Block word set 2651: @subsection Other system documentation 2652: @c --------------------------------------------------------------------- 2653: 2654: @table @i 2655: 2656: @item any restrictions a multiprogramming system places on the use of buffer addresses: 2657: No restrictions (yet). 2658: 2659: @item the number of blocks available for source and data: 2660: depends on your disk space. 2661: 2662: @end table 2663: 2664: 2665: @c ===================================================================== 2666: @node The optional Double Number word set, The optional Exception word set, The optional Block word set, ANS conformance 2667: @section The optional Double Number word set 2668: @c ===================================================================== 2669: 2670: @menu 1.15 anton 2671: * double-ambcond:: Ambiguous Conditions 1.14 anton 2672: @end menu 2673: 2674: 2675: @c --------------------------------------------------------------------- 1.15 anton 2676: @node double-ambcond, , The optional Double Number word set, The optional Double Number word set 1.14 anton 2677: @subsection Ambiguous conditions 2678: @c --------------------------------------------------------------------- 2679: 2680: @table @i 2681: 1.15 anton 2682: @item @var{d} outside of range of @var{n} in @code{D>S}: 1.14 anton 2683: The least significant cell of @var{d} is produced. 2684: 2685: @end table 2686: 2687: 2688: @c ===================================================================== 2689: @node The optional Exception word set, The optional Facility word set, The optional Double Number word set, ANS conformance 2690: @section The optional Exception word set 2691: @c ===================================================================== 2692: 2693: @menu 1.15 anton 2694: * exception-idef:: Implementation Defined Options 1.14 anton 2695: @end menu 2696: 2697: 2698: @c --------------------------------------------------------------------- 1.15 anton 2699: @node exception-idef, , The optional Exception word set, The optional Exception word set 1.14 anton 2700: @subsection Implementation Defined Options 2701: @c --------------------------------------------------------------------- 2702: 2703: @table @i 2704: @item @code{THROW}-codes used in the system: 2705: The codes -256@minus{}-511 are used for reporting signals (see 2706: @file{errore.fs}). The codes -512@minus{}-2047 are used for OS errors 2707: (for file and memory allocation operations). The mapping from OS error 2708: numbers to throw code is -512@minus{}@var{errno}. One side effect of 2709: this mapping is that undefined OS errors produce a message with a 2710: strange number; e.g., @code{-1000 THROW} results in @code{Unknown error 2711: 488} on my system. 2712: @end table 2713: 2714: @c ===================================================================== 2715: @node The optional Facility word set, The optional File-Access word set, The optional Exception word set, ANS conformance 2716: @section The optional Facility word set 2717: @c ===================================================================== 2718: 2719: @menu 1.15 anton 2720: * facility-idef:: Implementation Defined Options 2721: * facility-ambcond:: Ambiguous Conditions 1.14 anton 2722: @end menu 2723: 2724: 2725: @c --------------------------------------------------------------------- 2726: @node facility-idef, facility-ambcond, The optional Facility word set, The optional Facility word set 2727: @subsection Implementation Defined Options 2728: @c --------------------------------------------------------------------- 2729: 2730: @table @i 2731: 2732: @item encoding of keyboard events (@code{EKEY}): 2733: Not yet implemeted. 2734: 2735: @item duration of a system clock tick 2736: System dependent. With respect to @code{MS}, the time is specified in 2737: microseconds. How well the OS and the hardware implement this, is 2738: another question. 2739: 2740: @item repeatability to be expected from the execution of @code{MS}: 2741: System dependent. On Unix, a lot depends on load. If the system is 1.17 anton 2742: lightly loaded, and the delay is short enough that Gforth does not get 1.14 anton 2743: swapped out, the performance should be acceptable. Under MS-DOS and 2744: other single-tasking systems, it should be good. 2745: 2746: @end table 2747: 2748: 2749: @c --------------------------------------------------------------------- 1.15 anton 2750: @node facility-ambcond, , facility-idef, The optional Facility word set 1.14 anton 2751: @subsection Ambiguous conditions 2752: @c --------------------------------------------------------------------- 2753: 2754: @table @i 2755: 2756: @item @code{AT-XY} can't be performed on user output device: 2757: Largely terminal dependant. No range checks are done on the arguments. 2758: No errors are reported. You may see some garbage appearing, you may see 2759: simply nothing happen. 2760: 2761: @end table 2762: 2763: 2764: @c ===================================================================== 2765: @node The optional File-Access word set, The optional Floating-Point word set, The optional Facility word set, ANS conformance 2766: @section The optional File-Access word set 2767: @c ===================================================================== 2768: 2769: @menu 1.15 anton 2770: * file-idef:: Implementation Defined Options 2771: * file-ambcond:: Ambiguous Conditions 1.14 anton 2772: @end menu 2773: 2774: 2775: @c --------------------------------------------------------------------- 2776: @node file-idef, file-ambcond, The optional File-Access word set, The optional File-Access word set 2777: @subsection Implementation Defined Options 2778: @c --------------------------------------------------------------------- 2779: 2780: @table @i 2781: 2782: @item File access methods used: 2783: @code{R/O}, @code{R/W} and @code{BIN} work as you would 2784: expect. @code{W/O} translates into the C file opening mode @code{w} (or 2785: @code{wb}): The file is cleared, if it exists, and created, if it does 1.15 anton 2786: not (both with @code{open-file} and @code{create-file}). Under Unix 1.14 anton 2787: @code{create-file} creates a file with 666 permissions modified by your 2788: umask. 2789: 2790: @item file exceptions: 2791: The file words do not raise exceptions (except, perhaps, memory access 2792: faults when you pass illegal addresses or file-ids). 2793: 2794: @item file line terminator: 2795: System-dependent. Gforth uses C's newline character as line 2796: terminator. What the actual character code(s) of this are is 2797: system-dependent. 2798: 2799: @item file name format 2800: System dependent. Gforth just uses the file name format of your OS. 2801: 2802: @item information returned by @code{FILE-STATUS}: 2803: @code{FILE-STATUS} returns the most powerful file access mode allowed 2804: for the file: Either @code{R/O}, @code{W/O} or @code{R/W}. If the file 2805: cannot be accessed, @code{R/O BIN} is returned. @code{BIN} is applicable 2806: along with the retured mode. 2807: 2808: @item input file state after an exception when including source: 2809: All files that are left via the exception are closed. 2810: 2811: @item @var{ior} values and meaning: 1.15 anton 2812: The @var{ior}s returned by the file and memory allocation words are 2813: intended as throw codes. They typically are in the range 2814: -512@minus{}-2047 of OS errors. The mapping from OS error numbers to 2815: @var{ior}s is -512@minus{}@var{errno}. 1.14 anton 2816: 2817: @item maximum depth of file input nesting: 2818: limited by the amount of return stack, locals/TIB stack, and the number 2819: of open files available. This should not give you troubles. 2820: 2821: @item maximum size of input line: 2822: @code{/line}. Currently 255. 2823: 2824: @item methods of mapping block ranges to files: 2825: Currently, the block words automatically access the file 2826: @file{blocks.fb} in the currend working directory. More sophisticated 2827: methods could be implemented if there is demand (and a volunteer). 2828: 2829: @item number of string buffers provided by @code{S"}: 2830: 1 2831: 2832: @item size of string buffer used by @code{S"}: 2833: @code{/line}. currently 255. 2834: 2835: @end table 2836: 2837: @c --------------------------------------------------------------------- 1.15 anton 2838: @node file-ambcond, , file-idef, The optional File-Access word set 1.14 anton 2839: @subsection Ambiguous conditions 2840: @c --------------------------------------------------------------------- 2841: 2842: @table @i 2843: 2844: @item attempting to position a file outside it's boundaries: 2845: @code{REPOSITION-FILE} is performed as usual: Afterwards, 2846: @code{FILE-POSITION} returns the value given to @code{REPOSITION-FILE}. 2847: 2848: @item attempting to read from file positions not yet written: 2849: End-of-file, i.e., zero characters are read and no error is reported. 2850: 2851: @item @var{file-id} is invalid (@code{INCLUDE-FILE}): 2852: An appropriate exception may be thrown, but a memory fault or other 2853: problem is more probable. 2854: 2855: @item I/O exception reading or closing @var{file-id} (@code{include-file}, @code{included}): 2856: The @var{ior} produced by the operation, that discovered the problem, is 2857: thrown. 2858: 2859: @item named file cannot be opened (@code{included}): 2860: The @var{ior} produced by @code{open-file} is thrown. 2861: 2862: @item requesting an unmapped block number: 2863: There are no unmapped legal block numbers. On some operating systems, 2864: writing a block with a large number may overflow the file system and 2865: have an error message as consequence. 2866: 2867: @item using @code{source-id} when @code{blk} is non-zero: 2868: @code{source-id} performs its function. Typically it will give the id of 2869: the source which loaded the block. (Better ideas?) 2870: 2871: @end table 2872: 2873: 2874: @c ===================================================================== 2875: @node The optional Floating-Point word set, The optional Locals word set, The optional File-Access word set, ANS conformance 1.15 anton 2876: @section The optional Floating-Point word set 1.14 anton 2877: @c ===================================================================== 2878: 2879: @menu 1.15 anton 2880: * floating-idef:: Implementation Defined Options 2881: * floating-ambcond:: Ambiguous Conditions 1.14 anton 2882: @end menu 2883: 2884: 2885: @c --------------------------------------------------------------------- 2886: @node floating-idef, floating-ambcond, The optional Floating-Point word set, The optional Floating-Point word set 2887: @subsection Implementation Defined Options 2888: @c --------------------------------------------------------------------- 2889: 2890: @table @i 2891: 1.15 anton 2892: @item format and range of floating point numbers: 2893: System-dependent; the @code{double} type of C. 1.14 anton 2894: 1.15 anton 2895: @item results of @code{REPRESENT} when @var{float} is out of range: 2896: System dependent; @code{REPRESENT} is implemented using the C library 2897: function @code{ecvt()} and inherits its behaviour in this respect. 1.14 anton 2898: 1.15 anton 2899: @item rounding or truncation of floating-point numbers: 2900: What's the question?!! 1.14 anton 2901: 1.15 anton 2902: @item size of floating-point stack: 2903: @code{s" FLOATING-STACK" environment? drop .}. Can be changed at startup 2904: with the command-line option @code{-f}. 1.14 anton 2905: 1.15 anton 2906: @item width of floating-point stack: 2907: @code{1 floats}. 1.14 anton 2908: 2909: @end table 2910: 2911: 2912: @c --------------------------------------------------------------------- 1.15 anton 2913: @node floating-ambcond, , floating-idef, The optional Floating-Point word set 2914: @subsection Ambiguous conditions 1.14 anton 2915: @c --------------------------------------------------------------------- 2916: 2917: @table @i 2918: 1.15 anton 2919: @item @code{df@@} or @code{df!} used with an address that is not double-float aligned: 2920: System-dependent. Typically results in an alignment fault like other 2921: alignment violations. 1.14 anton 2922: 1.15 anton 2923: @item @code{f@@} or @code{f!} used with an address that is not float aligned: 2924: System-dependent. Typically results in an alignment fault like other 2925: alignment violations. 1.14 anton 2926: 1.15 anton 2927: @item Floating-point result out of range: 2928: System-dependent. Can result in a @code{-55 THROW} (Floating-point 2929: unidentified fault), or can produce a special value representing, e.g., 2930: Infinity. 1.14 anton 2931: 1.15 anton 2932: @item @code{sf@@} or @code{sf!} used with an address that is not single-float aligned: 2933: System-dependent. Typically results in an alignment fault like other 2934: alignment violations. 1.14 anton 2935: 1.15 anton 2936: @item BASE is not decimal (@code{REPRESENT}, @code{F.}, @code{FE.}, @code{FS.}): 2937: The floating-point number is converted into decimal nonetheless. 1.14 anton 2938: 1.15 anton 2939: @item Both arguments are equal to zero (@code{FATAN2}): 2940: System-dependent. @code{FATAN2} is implemented using the C library 2941: function @code{atan2()}. 1.14 anton 2942: 1.15 anton 2943: @item Using ftan on an argument @var{r1} where cos(@var{r1}) is zero: 2944: System-dependent. Anyway, typically the cos of @var{r1} will not be zero 2945: because of small errors and the tan will be a very large (or very small) 2946: but finite number. 1.14 anton 2947: 1.15 anton 2948: @item @var{d} cannot be presented precisely as a float in @code{D>F}: 2949: The result is rounded to the nearest float. 1.14 anton 2950: 1.15 anton 2951: @item dividing by zero: 2952: @code{-55 throw} (Floating-point unidentified fault) 1.14 anton 2953: 1.15 anton 2954: @item exponent too big for conversion (@code{DF!}, @code{DF@@}, @code{SF!}, @code{SF@@}): 2955: System dependent. On IEEE-FP based systems the number is converted into 2956: an infinity. 1.14 anton 2957: 1.15 anton 2958: @item @var{float}<1 (@code{facosh}): 2959: @code{-55 throw} (Floating-point unidentified fault) 1.14 anton 2960: 1.15 anton 2961: @item @var{float}=<-1 (@code{flnp1}): 2962: @code{-55 throw} (Floating-point unidentified fault). On IEEE-FP systems 2963: negative infinity is typically produced for @var{float}=-1. 1.14 anton 2964: 1.15 anton 2965: @item @var{float}=<0 (@code{fln}, @code{flog}): 2966: @code{-55 throw} (Floating-point unidentified fault). On IEEE-FP systems 2967: negative infinity is typically produced for @var{float}=0. 1.14 anton 2968: 1.15 anton 2969: @item @var{float}<0 (@code{fasinh}, @code{fsqrt}): 2970: @code{-55 throw} (Floating-point unidentified fault). @code{fasinh} 2971: produces values for these inputs on my Linux box (Bug in the C library?) 1.14 anton 2972: 1.15 anton 2973: @item |@var{float}|>1 (@code{facos}, @code{fasin}, @code{fatanh}): 2974: @code{-55 throw} (Floating-point unidentified fault). 1.14 anton 2975: 1.15 anton 2976: @item integer part of float cannot be represented by @var{d} in @code{f>d}: 2977: @code{-55 throw} (Floating-point unidentified fault). 1.14 anton 2978: 1.15 anton 2979: @item string larger than pictured numeric output area (@code{f.}, @code{fe.}, @code{fs.}): 2980: This does not happen. 2981: @end table 1.14 anton 2982: 2983: 2984: 2985: @c ===================================================================== 1.15 anton 2986: @node The optional Locals word set, The optional Memory-Allocation word set, The optional Floating-Point word set, ANS conformance 2987: @section The optional Locals word set 1.14 anton 2988: @c ===================================================================== 2989: 2990: @menu 1.15 anton 2991: * locals-idef:: Implementation Defined Options 2992: * locals-ambcond:: Ambiguous Conditions 1.14 anton 2993: @end menu 2994: 2995: 2996: @c --------------------------------------------------------------------- 1.15 anton 2997: @node locals-idef, locals-ambcond, The optional Locals word set, The optional Locals word set 1.14 anton 2998: @subsection Implementation Defined Options 2999: @c --------------------------------------------------------------------- 3000: 3001: @table @i 3002: 1.15 anton 3003: @item maximum number of locals in a definition: 3004: @code{s" #locals" environment? drop .}. Currently 15. This is a lower 3005: bound, e.g., on a 32-bit machine there can be 41 locals of up to 8 3006: characters. The number of locals in a definition is bounded by the size 3007: of locals-buffer, which contains the names of the locals. 1.14 anton 3008: 3009: @end table 3010: 3011: 3012: @c --------------------------------------------------------------------- 1.15 anton 3013: @node locals-ambcond, , locals-idef, The optional Locals word set 1.14 anton 3014: @subsection Ambiguous conditions 3015: @c --------------------------------------------------------------------- 3016: 3017: @table @i 3018: 1.15 anton 3019: @item executing a named local in interpretation state: 3020: @code{-14 throw} (Interpreting a compile-only word). 1.14 anton 3021: 1.15 anton 3022: @item @var{name} not defined by @code{VALUE} or @code{(LOCAL)} (@code{TO}): 3023: @code{-32 throw} (Invalid name argument) 1.14 anton 3024: 3025: @end table 3026: 3027: 3028: @c ===================================================================== 1.15 anton 3029: @node The optional Memory-Allocation word set, The optional Programming-Tools word set, The optional Locals word set, ANS conformance 3030: @section The optional Memory-Allocation word set 1.14 anton 3031: @c ===================================================================== 3032: 3033: @menu 1.15 anton 3034: * memory-idef:: Implementation Defined Options 1.14 anton 3035: @end menu 3036: 3037: 3038: @c --------------------------------------------------------------------- 1.15 anton 3039: @node memory-idef, , The optional Memory-Allocation word set, The optional Memory-Allocation word set 1.14 anton 3040: @subsection Implementation Defined Options 3041: @c --------------------------------------------------------------------- 3042: 3043: @table @i 3044: 1.15 anton 3045: @item values and meaning of @var{ior}: 3046: The @var{ior}s returned by the file and memory allocation words are 3047: intended as throw codes. They typically are in the range 3048: -512@minus{}-2047 of OS errors. The mapping from OS error numbers to 3049: @var{ior}s is -512@minus{}@var{errno}. 1.14 anton 3050: 3051: @end table 3052: 3053: @c ===================================================================== 1.15 anton 3054: @node The optional Programming-Tools word set, The optional Search-Order word set, The optional Memory-Allocation word set, ANS conformance 3055: @section The optional Programming-Tools word set 1.14 anton 3056: @c ===================================================================== 3057: 3058: @menu 1.15 anton 3059: * programming-idef:: Implementation Defined Options 3060: * programming-ambcond:: Ambiguous Conditions 1.14 anton 3061: @end menu 3062: 3063: 3064: @c --------------------------------------------------------------------- 1.15 anton 3065: @node programming-idef, programming-ambcond, The optional Programming-Tools word set, The optional Programming-Tools word set 1.14 anton 3066: @subsection Implementation Defined Options 3067: @c --------------------------------------------------------------------- 3068: 3069: @table @i 3070: 1.15 anton 3071: @item ending sequence for input following @code{;code} and @code{code}: 3072: Not implemented (yet). 1.14 anton 3073: 1.15 anton 3074: @item manner of processing input following @code{;code} and @code{code}: 3075: Not implemented (yet). 3076: 3077: @item search order capability for @code{EDITOR} and @code{ASSEMBLER}: 3078: Not implemented (yet). If they were implemented, they would use the 3079: search order wordset. 3080: 3081: @item source and format of display by @code{SEE}: 3082: The source for @code{see} is the intermediate code used by the inner 3083: interpreter. The current @code{see} tries to output Forth source code 3084: as well as possible. 3085: 1.14 anton 3086: @end table 3087: 3088: @c --------------------------------------------------------------------- 1.15 anton 3089: @node programming-ambcond, , programming-idef, The optional Programming-Tools word set 1.14 anton 3090: @subsection Ambiguous conditions 3091: @c --------------------------------------------------------------------- 3092: 3093: @table @i 3094: 1.15 anton 3095: @item deleting the compilation wordlist (@code{FORGET}): 3096: Not implemented (yet). 1.14 anton 3097: 1.15 anton 3098: @item fewer than @var{u}+1 items on the control flow stack (@code{CS-PICK}, @code{CS-ROLL}): 3099: This typically results in an @code{abort"} with a descriptive error 3100: message (may change into a @code{-22 throw} (Control structure mismatch) 3101: in the future). You may also get a memory access error. If you are 3102: unlucky, this ambiguous condition is not caught. 3103: 3104: @item @var{name} can't be found (@code{forget}): 3105: Not implemented (yet). 1.14 anton 3106: 1.15 anton 3107: @item @var{name} not defined via @code{CREATE}: 3108: @code{;code} is not implemented (yet). If it were, it would behave like 3109: @code{DOES>} in this respect, i.e., change the execution semantics of 3110: the last defined word no matter how it was defined. 1.14 anton 3111: 1.15 anton 3112: @item @code{POSTPONE} applied to @code{[IF]}: 3113: After defining @code{: X POSTPONE [IF] ; IMMEDIATE}. @code{X} is 3114: equivalent to @code{[IF]}. 1.14 anton 3115: 1.15 anton 3116: @item reaching the end of the input source before matching @code{[ELSE]} or @code{[THEN]}: 3117: Continue in the same state of conditional compilation in the next outer 3118: input source. Currently there is no warning to the user about this. 1.14 anton 3119: 1.15 anton 3120: @item removing a needed definition (@code{FORGET}): 3121: Not implemented (yet). 1.14 anton 3122: 3123: @end table 3124: 3125: 3126: @c ===================================================================== 1.15 anton 3127: @node The optional Search-Order word set, , The optional Programming-Tools word set, ANS conformance 3128: @section The optional Search-Order word set 1.14 anton 3129: @c ===================================================================== 3130: 3131: @menu 1.15 anton 3132: * search-idef:: Implementation Defined Options 3133: * search-ambcond:: Ambiguous Conditions 1.14 anton 3134: @end menu 3135: 3136: 3137: @c --------------------------------------------------------------------- 1.15 anton 3138: @node search-idef, search-ambcond, The optional Search-Order word set, The optional Search-Order word set 1.14 anton 3139: @subsection Implementation Defined Options 3140: @c --------------------------------------------------------------------- 3141: 3142: @table @i 3143: 1.15 anton 3144: @item maximum number of word lists in search order: 3145: @code{s" wordlists" environment? drop .}. Currently 16. 3146: 3147: @item minimum search order: 3148: @code{root root}. 1.14 anton 3149: 3150: @end table 3151: 3152: @c --------------------------------------------------------------------- 1.15 anton 3153: @node search-ambcond, , search-idef, The optional Search-Order word set 1.14 anton 3154: @subsection Ambiguous conditions 3155: @c --------------------------------------------------------------------- 3156: 3157: @table @i 3158: 1.15 anton 3159: @item changing the compilation wordlist (during compilation): 3160: The definition is put into the wordlist that is the compilation wordlist 3161: when @code{REVEAL} is executed (by @code{;}, @code{DOES>}, 3162: @code{RECURSIVE}, etc.). 1.14 anton 3163: 1.15 anton 3164: @item search order empty (@code{previous}): 3165: @code{abort" Vocstack empty"}. 1.14 anton 3166: 1.15 anton 3167: @item too many word lists in search order (@code{also}): 3168: @code{abort" Vocstack full"}. 1.14 anton 3169: 3170: @end table 1.13 anton 3171: 3172: 1.17 anton 3173: @node Model, Emacs and Gforth, ANS conformance, Top 1.4 anton 3174: @chapter Model 3175: 1.17 anton 3176: @node Emacs and Gforth, Internals, Model, Top 3177: @chapter Emacs and Gforth 1.4 anton 3178: 1.17 anton 3179: Gforth comes with @file{gforth.el}, an improved version of 1.4 anton 3180: @file{forth.el} by Goran Rydqvist (icluded in the TILE package). The 3181: improvements are a better (but still not perfect) handling of 3182: indentation. I have also added comment paragraph filling (@kbd{M-q}), 1.8 anton 3183: commenting (@kbd{C-x \}) and uncommenting (@kbd{C-u C-x \}) regions and 3184: removing debugging tracers (@kbd{C-x ~}, @pxref{Debugging}). I left the 3185: stuff I do not use alone, even though some of it only makes sense for 3186: TILE. To get a description of these features, enter Forth mode and type 3187: @kbd{C-h m}. 1.4 anton 3188: 1.17 anton 3189: In addition, Gforth supports Emacs quite well: The source code locations 1.4 anton 3190: given in error messages, debugging output (from @code{~~}) and failed 3191: assertion messages are in the right format for Emacs' compilation mode 3192: (@pxref{Compilation, , Running Compilations under Emacs, emacs, Emacs 3193: Manual}) so the source location corresponding to an error or other 3194: message is only a few keystrokes away (@kbd{C-x `} for the next error, 3195: @kbd{C-c C-c} for the error under the cursor). 3196: 3197: Also, if you @code{include} @file{etags.fs}, a new @file{TAGS} file 3198: (@pxref{Tags, , Tags Tables, emacs, Emacs Manual}) will be produced that 3199: contains the definitions of all words defined afterwards. You can then 3200: find the source for a word using @kbd{M-.}. Note that emacs can use 1.17 anton 3201: several tags files at the same time (e.g., one for the Gforth sources 1.4 anton 3202: and one for your program). 3203: 3204: To get all these benefits, add the following lines to your @file{.emacs} 3205: file: 3206: 3207: @example 3208: (autoload 'forth-mode "gforth.el") 3209: (setq auto-mode-alist (cons '("\\.fs\\'" . forth-mode) auto-mode-alist)) 3210: @end example 3211: 1.17 anton 3212: @node Internals, Bugs, Emacs and Gforth, Top 1.3 anton 3213: @chapter Internals 3214: 1.17 anton 3215: Reading this section is not necessary for programming with Gforth. It 3216: should be helpful for finding your way in the Gforth sources. 1.3 anton 3217: 1.24 ! anton 3218: The ideas in this section have also been published in the papers ! 3219: @cite{ANS fig/GNU/??? Forth} (in German) by Bernd Paysan, presented at ! 3220: the Forth-Tagung '93 and @cite{A Portable Forth Engine} by M. Anton ! 3221: Ertl, presented at EuroForth '93; the latter is available at ! 3222: @*@file{}. ! 3223: 1.4 anton 3224: @menu 3225: * Portability:: 3226: * Threading:: 3227: * Primitives:: 3228: * System Architecture:: 1.17 anton 3229: * Performance:: 1.4 anton 3230: @end menu 3231: 3232: @node Portability, Threading, Internals, Internals 1.3 anton 3233: @section Portability 3234: 3235: One of the main goals of the effort is availability across a wide range 3236: of personal machines. fig-Forth, and, to a lesser extent, F83, achieved 3237: this goal by manually coding the engine in assembly language for several 3238: then-popular processors. This approach is very labor-intensive and the 3239: results are short-lived due to progress in computer architecture. 3240: 3241: Others have avoided this problem by coding in C, e.g., Mitch Bradley 3242: (cforth), Mikael Patel (TILE) and Dirk Zoller (pfe). This approach is 3243: particularly popular for UNIX-based Forths due to the large variety of 3244: architectures of UNIX machines. Unfortunately an implementation in C 3245: does not mix well with the goals of efficiency and with using 3246: traditional techniques: Indirect or direct threading cannot be expressed 3247: in C, and switch threading, the fastest technique available in C, is 3248: significantly slower. Another problem with C is that it's very 3249: cumbersome to express double integer arithmetic. 3250: 3251: Fortunately, there is a portable language that does not have these 3252: limitations: GNU C, the version of C processed by the GNU C compiler 3253: (@pxref{C Extensions, , Extensions to the C Language Family, gcc.info, 3254: GNU C Manual}). Its labels as values feature (@pxref{Labels as Values, , 3255: Labels as Values, gcc.info, GNU C Manual}) makes direct and indirect 3256: threading possible, its @code{long long} type (@pxref{Long Long, , 3257: Double-Word Integers, gcc.info, GNU C Manual}) corresponds to Forths 3258: double numbers. GNU C is available for free on all important (and many 3259: unimportant) UNIX machines, VMS, 80386s running MS-DOS, the Amiga, and 3260: the Atari ST, so a Forth written in GNU C can run on all these 1.17 anton 3261: machines. 1.3 anton 3262: 3263: Writing in a portable language has the reputation of producing code that 3264: is slower than assembly. For our Forth engine we repeatedly looked at 3265: the code produced by the compiler and eliminated most compiler-induced 3266: inefficiencies by appropriate changes in the source-code. 3267: 3268: However, register allocation cannot be portably influenced by the 3269: programmer, leading to some inefficiencies on register-starved 3270: machines. We use explicit register declarations (@pxref{Explicit Reg 3271: Vars, , Variables in Specified Registers, gcc.info, GNU C Manual}) to 3272: improve the speed on some machines. They are turned on by using the 3273: @code{gcc} switch @code{-DFORCE_REG}. Unfortunately, this feature not 3274: only depends on the machine, but also on the compiler version: On some 3275: machines some compiler versions produce incorrect code when certain 3276: explicit register declarations are used. So by default 3277: @code{-DFORCE_REG} is not used. 3278: 1.4 anton 3279: @node Threading, Primitives, Portability, Internals 1.3 anton 3280: @section Threading 3281: 3282: GNU C's labels as values extension (available since @code{gcc-2.0}, 3283: @pxref{Labels as Values, , Labels as Values, gcc.info, GNU C Manual}) 3284: makes it possible to take the address of @var{label} by writing 3285: @code{&&@var{label}}. This address can then be used in a statement like 3286: @code{goto *@var{address}}. I.e., @code{goto *&&x} is the same as 3287: @code{goto x}. 3288: 3289: With this feature an indirect threaded NEXT looks like: 3290: @example 3291: cfa = *ip++; 3292: ca = *cfa; 3293: goto *ca; 3294: @end example 3295: For those unfamiliar with the names: @code{ip} is the Forth instruction 3296: pointer; the @code{cfa} (code-field address) corresponds to ANS Forths 3297: execution token and points to the code field of the next word to be 3298: executed; The @code{ca} (code address) fetched from there points to some 3299: executable code, e.g., a primitive or the colon definition handler 3300: @code{docol}. 3301: 3302: Direct threading is even simpler: 3303: @example 3304: ca = *ip++; 3305: goto *ca; 3306: @end example 3307: 3308: Of course we have packaged the whole thing neatly in macros called 3309: @code{NEXT} and @code{NEXT1} (the part of NEXT after fetching the cfa). 3310: 1.4 anton 3311: @menu 3312: * Scheduling:: 3313: * Direct or Indirect Threaded?:: 3314: * DOES>:: 3315: @end menu 3316: 3317: @node Scheduling, Direct or Indirect Threaded?, Threading, Threading 1.3 anton 3318: @subsection Scheduling 3319: 3320: There is a little complication: Pipelined and superscalar processors, 3321: i.e., RISC and some modern CISC machines can process independent 3322: instructions while waiting for the results of an instruction. The 3323: compiler usually reorders (schedules) the instructions in a way that 3324: achieves good usage of these delay slots. However, on our first tries 3325: the compiler did not do well on scheduling primitives. E.g., for 3326: @code{+} implemented as 3327: @example 3328: n=sp[0]+sp[1]; 3329: sp++; 3330: sp[0]=n; 3331: NEXT; 3332: @end example 3333: the NEXT comes strictly after the other code, i.e., there is nearly no 3334: scheduling. After a little thought the problem becomes clear: The 3335: compiler cannot know that sp and ip point to different addresses (and 1.4 anton 3336: the version of @code{gcc} we used would not know it even if it was 3337: possible), so it could not move the load of the cfa above the store to 3338: the TOS. Indeed the pointers could be the same, if code on or very near 3339: the top of stack were executed. In the interest of speed we chose to 3340: forbid this probably unused ``feature'' and helped the compiler in 3341: scheduling: NEXT is divided into the loading part (@code{NEXT_P1}) and 3342: the goto part (@code{NEXT_P2}). @code{+} now looks like: 1.3 anton 3343: @example 3344: n=sp[0]+sp[1]; 3345: sp++; 3346: NEXT_P1; 3347: sp[0]=n; 3348: NEXT_P2; 3349: @end example 1.4 anton 3350: This can be scheduled optimally by the compiler. 1.3 anton 3351: 3352: This division can be turned off with the switch @code{-DCISC_NEXT}. This 3353: switch is on by default on machines that do not profit from scheduling 3354: (e.g., the 80386), in order to preserve registers. 3355: 1.4 anton 3356: @node Direct or Indirect Threaded?, DOES>, Scheduling, Threading 1.3 anton 3357: @subsection Direct or Indirect Threaded? 3358: 3359: Both! After packaging the nasty details in macro definitions we 3360: realized that we could switch between direct and indirect threading by 3361: simply setting a compilation flag (@code{-DDIRECT_THREADED}) and 3362: defining a few machine-specific macros for the direct-threading case. 3363: On the Forth level we also offer access words that hide the 3364: differences between the threading methods (@pxref{Threading Words}). 3365: 3366: Indirect threading is implemented completely 3367: machine-independently. Direct threading needs routines for creating 3368: jumps to the executable code (e.g. to docol or dodoes). These routines 3369: are inherently machine-dependent, but they do not amount to many source 3370: lines. I.e., even porting direct threading to a new machine is a small 3371: effort. 3372: 1.4 anton 3373: @node DOES>, , Direct or Indirect Threaded?, Threading 1.3 anton 3374: @subsection DOES> 3375: One of the most complex parts of a Forth engine is @code{dodoes}, i.e., 3376: the chunk of code executed by every word defined by a 3377: @code{CREATE}...@code{DOES>} pair. The main problem here is: How to find 3378: the Forth code to be executed, i.e. the code after the @code{DOES>} (the 3379: DOES-code)? There are two solutions: 3380: 3381: In fig-Forth the code field points directly to the dodoes and the 3382: DOES-code address is stored in the cell after the code address 3383: (i.e. at cfa cell+). It may seem that this solution is illegal in the 3384: Forth-79 and all later standards, because in fig-Forth this address 3385: lies in the body (which is illegal in these standards). However, by 3386: making the code field larger for all words this solution becomes legal 3387: again. We use this approach for the indirect threaded version. Leaving 3388: a cell unused in most words is a bit wasteful, but on the machines we 3389: are targetting this is hardly a problem. The other reason for having a 3390: code field size of two cells is to avoid having different image files 1.4 anton 3391: for direct and indirect threaded systems (@pxref{System Architecture}). 1.3 anton 3392: 3393: The other approach is that the code field points or jumps to the cell 3394: after @code{DOES}. In this variant there is a jump to @code{dodoes} at 3395: this address. @code{dodoes} can then get the DOES-code address by 3396: computing the code address, i.e., the address of the jump to dodoes, 3397: and add the length of that jump field. A variant of this is to have a 3398: call to @code{dodoes} after the @code{DOES>}; then the return address 3399: (which can be found in the return register on RISCs) is the DOES-code 3400: address. Since the two cells available in the code field are usually 3401: used up by the jump to the code address in direct threading, we use 3402: this approach for direct threading. We did not want to add another 3403: cell to the code field. 3404: 1.4 anton 3405: @node Primitives, System Architecture, Threading, Internals 1.3 anton 3406: @section Primitives 3407: 1.4 anton 3408: @menu 3409: * Automatic Generation:: 3410: * TOS Optimization:: 3411: * Produced code:: 3412: @end menu 3413: 3414: @node Automatic Generation, TOS Optimization, Primitives, Primitives 1.3 anton 3415: @subsection Automatic Generation 3416: 3417: Since the primitives are implemented in a portable language, there is no 3418: longer any need to minimize the number of primitives. On the contrary, 3419: having many primitives is an advantage: speed. In order to reduce the 3420: number of errors in primitives and to make programming them easier, we 3421: provide a tool, the primitive generator (@file{prims2x.fs}), that 3422: automatically generates most (and sometimes all) of the C code for a 3423: primitive from the stack effect notation. The source for a primitive 3424: has the following form: 3425: 3426: @format 3427: @var{Forth-name} @var{stack-effect} @var{category} [@var{pronounc.}] 3428: [@code{""}@var{glossary entry}@code{""}] 3429: @var{C code} 3430: [@code{:} 3431: @var{Forth code}] 3432: @end format 3433: 3434: The items in brackets are optional. The category and glossary fields 3435: are there for generating the documentation, the Forth code is there 3436: for manual implementations on machines without GNU C. E.g., the source 3437: for the primitive @code{+} is: 3438: @example 3439: + n1 n2 -- n core plus 3440: n = n1+n2; 3441: @end example 3442: 3443: This looks like a specification, but in fact @code{n = n1+n2} is C 3444: code. Our primitive generation tool extracts a lot of information from 3445: the stack effect notations@footnote{We use a one-stack notation, even 3446: though we have separate data and floating-point stacks; The separate 3447: notation can be generated easily from the unified notation.}: The number 3448: of items popped from and pushed on the stack, their type, and by what 3449: name they are referred to in the C code. It then generates a C code 3450: prelude and postlude for each primitive. The final C code for @code{+} 3451: looks like this: 3452: 3453: @example 3454: I_plus: /* + ( n1 n2 -- n ) */ /* label, stack effect */ 3455: /* */ /* documentation */ 1.4 anton 3456: @{ 1.3 anton 3457: DEF_CA /* definition of variable ca (indirect threading) */ 3458: Cell n1; /* definitions of variables */ 3459: Cell n2; 3460: Cell n; 3461: n1 = (Cell) sp[1]; /* input */ 3462: n2 = (Cell) TOS; 3463: sp += 1; /* stack adjustment */ 3464: NAME("+") /* debugging output (with -DDEBUG) */ 1.4 anton 3465: @{ 1.3 anton 3466: n = n1+n2; /* C code taken from the source */ 1.4 anton 3467: @} 1.3 anton 3468: NEXT_P1; /* NEXT part 1 */ 3469: TOS = (Cell)n; /* output */ 3470: NEXT_P2; /* NEXT part 2 */ 1.4 anton 3471: @} 1.3 anton 3472: @end example 3473: 3474: This looks long and inefficient, but the GNU C compiler optimizes quite 3475: well and produces optimal code for @code{+} on, e.g., the R3000 and the 3476: HP RISC machines: Defining the @code{n}s does not produce any code, and 3477: using them as intermediate storage also adds no cost. 3478: 3479: There are also other optimizations, that are not illustrated by this 3480: example: Assignments between simple variables are usually for free (copy 3481: propagation). If one of the stack items is not used by the primitive 3482: (e.g. in @code{drop}), the compiler eliminates the load from the stack 3483: (dead code elimination). On the other hand, there are some things that 3484: the compiler does not do, therefore they are performed by 3485: @file{prims2x.fs}: The compiler does not optimize code away that stores 3486: a stack item to the place where it just came from (e.g., @code{over}). 3487: 3488: While programming a primitive is usually easy, there are a few cases 3489: where the programmer has to take the actions of the generator into 3490: account, most notably @code{?dup}, but also words that do not (always) 3491: fall through to NEXT. 3492: 1.4 anton 3493: @node TOS Optimization, Produced code, Automatic Generation, Primitives 1.3 anton 3494: @subsection TOS Optimization 3495: 3496: An important optimization for stack machine emulators, e.g., Forth 3497: engines, is keeping one or more of the top stack items in 1.4 anton 3498: registers. If a word has the stack effect @var{in1}...@var{inx} @code{--} 3499: @var{out1}...@var{outy}, keeping the top @var{n} items in registers 1.3 anton 3500: @itemize 3501: @item 3502: is better than keeping @var{n-1} items, if @var{x>=n} and @var{y>=n}, 3503: due to fewer loads from and stores to the stack. 3504: @item is slower than keeping @var{n-1} items, if @var{x<>y} and @var{x<n} and 3505: @var{y<n}, due to additional moves between registers. 3506: @end itemize 3507: 3508: In particular, keeping one item in a register is never a disadvantage, 3509: if there are enough registers. Keeping two items in registers is a 3510: disadvantage for frequent words like @code{?branch}, constants, 3511: variables, literals and @code{i}. Therefore our generator only produces 3512: code that keeps zero or one items in registers. The generated C code 3513: covers both cases; the selection between these alternatives is made at 3514: C-compile time using the switch @code{-DUSE_TOS}. @code{TOS} in the C 3515: code for @code{+} is just a simple variable name in the one-item case, 3516: otherwise it is a macro that expands into @code{sp[0]}. Note that the 3517: GNU C compiler tries to keep simple variables like @code{TOS} in 3518: registers, and it usually succeeds, if there are enough registers. 3519: 3520: The primitive generator performs the TOS optimization for the 3521: floating-point stack, too (@code{-DUSE_FTOS}). For floating-point 3522: operations the benefit of this optimization is even larger: 3523: floating-point operations take quite long on most processors, but can be 3524: performed in parallel with other operations as long as their results are 3525: not used. If the FP-TOS is kept in a register, this works. If 3526: it is kept on the stack, i.e., in memory, the store into memory has to 3527: wait for the result of the floating-point operation, lengthening the 3528: execution time of the primitive considerably. 3529: 3530: The TOS optimization makes the automatic generation of primitives a 3531: bit more complicated. Just replacing all occurrences of @code{sp[0]} by 3532: @code{TOS} is not sufficient. There are some special cases to 3533: consider: 3534: @itemize 3535: @item In the case of @code{dup ( w -- w w )} the generator must not 3536: eliminate the store to the original location of the item on the stack, 3537: if the TOS optimization is turned on. 1.4 anton 3538: @item Primitives with stack effects of the form @code{--} 3539: @var{out1}...@var{outy} must store the TOS to the stack at the start. 3540: Likewise, primitives with the stack effect @var{in1}...@var{inx} @code{--} 1.3 anton 3541: must load the TOS from the stack at the end. But for the null stack 3542: effect @code{--} no stores or loads should be generated. 3543: @end itemize 3544: 1.4 anton 3545: @node Produced code, , TOS Optimization, Primitives 1.3 anton 3546: @subsection Produced code 3547: 3548: To see what assembly code is produced for the primitives on your machine 3549: with your compiler and your flag settings, type @code{make engine.s} and 1.4 anton 3550: look at the resulting file @file{engine.s}. 1.3 anton 3551: 1.17 anton 3552: @node System Architecture, Performance, Primitives, Internals 1.3 anton 3553: @section System Architecture 3554: 3555: Our Forth system consists not only of primitives, but also of 3556: definitions written in Forth. Since the Forth compiler itself belongs 3557: to those definitions, it is not possible to start the system with the 3558: primitives and the Forth source alone. Therefore we provide the Forth 3559: code as an image file in nearly executable form. At the start of the 3560: system a C routine loads the image file into memory, sets up the 3561: memory (stacks etc.) according to information in the image file, and 3562: starts executing Forth code. 3563: 3564: The image file format is a compromise between the goals of making it 3565: easy to generate image files and making them portable. The easiest way 3566: to generate an image file is to just generate a memory dump. However, 3567: this kind of image file cannot be used on a different machine, or on 3568: the next version of the engine on the same machine, it even might not 3569: work with the same engine compiled by a different version of the C 3570: compiler. We would like to have as few versions of the image file as 3571: possible, because we do not want to distribute many versions of the 3572: same image file, and to make it easy for the users to use their image 3573: files on many machines. We currently need to create a different image 3574: file for machines with different cell sizes and different byte order 1.17 anton 3575: (little- or big-endian)@footnote{We are considering adding information to the 1.3 anton 3576: image file that enables the loader to change the byte order.}. 3577: 3578: Forth code that is going to end up in a portable image file has to 1.4 anton 3579: comply to some restrictions: addresses have to be stored in memory with 3580: special words (@code{A!}, @code{A,}, etc.) in order to make the code 3581: relocatable. Cells, floats, etc., have to be stored at the natural 3582: alignment boundaries@footnote{E.g., store floats (8 bytes) at an address 3583: dividable by~8. This happens automatically in our system when you use 3584: the ANS Forth alignment words.}, in order to avoid alignment faults on 3585: machines with stricter alignment. The image file is produced by a 3586: metacompiler (@file{cross.fs}). 1.3 anton 3587: 3588: So, unlike the image file of Mitch Bradleys @code{cforth}, our image 3589: file is not directly executable, but has to undergo some manipulations 3590: during loading. Address relocation is performed at image load-time, not 3591: at run-time. The loader also has to replace tokens standing for 3592: primitive calls with the appropriate code-field addresses (or code 3593: addresses in the case of direct threading). 1.4 anton 3594: 1.17 anton 3595: @node Performance, , System Architecture, Internals 3596: @section Performance 3597: 3598: On RISCs the Gforth engine is very close to optimal; i.e., it is usually 3599: impossible to write a significantly faster engine. 3600: 3601: On register-starved machines like the 386 architecture processors 3602: improvements are possible, because @code{gcc} does not utilize the 3603: registers as well as a human, even with explicit register declarations; 3604: e.g., Bernd Beuster wrote a Forth system fragment in assembly language 3605: and hand-tuned it for the 486; this system is 1.19 times faster on the 3606: Sieve benchmark on a 486DX2/66 than Gforth compiled with 3607: @code{gcc-2.6.3} with @code{-DFORCE_REG}. 3608: 3609: However, this potential advantage of assembly language implementations 3610: is not necessarily realized in complete Forth systems: We compared 3611: Gforth (compiled with @code{gcc-2.6.3} and @code{-DFORCE_REG}) with 1.18 anton 3612: Win32Forth 1.2093 and LMI's NT Forth (Beta, May 1994), two systems 3613: written in assembly, and with two systems written in C: PFE-0.9.11 3614: (compiled with @code{gcc-2.6.3} with the default configuration for 3615: Linux: @code{-O2 -fomit-frame-pointer -DUSE_REGS}) and ThisForth Beta 3616: (compiled with gcc-2.6.3 -O3 -fomit-frame-pointer). We benchmarked 3617: Gforth, PFE and ThisForth on a 486DX2/66 under Linux. Kenneth O'Heskin 3618: kindly provided the results for Win32Forth and NT Forth on a 486DX2/66 3619: with similar memory performance under Windows NT. 1.17 anton 3620: 3621: We used four small benchmarks: the ubiquitous Sieve; bubble-sorting and 3622: matrix multiplication come from the Stanford integer benchmarks and have 3623: been translated into Forth by Martin Fraeman; we used the versions 3624: included in the TILE Forth package; and a recursive Fibonacci number 1.24 ! anton 3625: computation for benchmarking calling performance. The following table shows 1.17 anton 3626: the time taken for the benchmarks scaled by the time taken by Gforth (in 3627: other words, it shows the speedup factor that Gforth achieved over the 3628: other systems). 3629: 3630: @example 3631: relative Win32- NT This- 3632: time Gforth Forth Forth PFE Forth 3633: sieve 1.00 1.30 1.07 1.67 2.98 3634: bubble 1.00 1.30 1.40 1.66 3635: matmul 1.00 1.40 1.29 2.24 3636: fib 1.00 1.44 1.26 1.82 2.82 3637: @end example 3638: 3639: You may find the good performance of Gforth compared with the systems 3640: written in assembly language quite surprising. One important reason for 3641: the disappointing performance of these systems is probably that they are 3642: not written optimally for the 486 (e.g., they use the @code{lods} 3643: instruction). In addition, Win32Forth uses a comfortable, but costly 3644: method for relocating the Forth image: like @code{cforth}, it computes 3645: the actual addresses at run time, resulting in two address computations 3646: per NEXT (@pxref{System Architecture}). 3647: 3648: The speedup of Gforth over PFE and ThisForth can be easily explained 3649: with the self-imposed restriction to standard C (although the measured 3650: implementation of PFE uses a GNU C extension: global register 3651: variables), which makes efficient threading impossible. Moreover, 3652: current C compilers have a hard time optimizing other aspects of the 3653: ThisForth source. 3654: 3655: Note that the performance of Gforth on 386 architecture processors 3656: varies widely with the version of @code{gcc} used. E.g., @code{gcc-2.5.8} 3657: failed to allocate any of the virtual machine registers into real 3658: machine registers by itself and would not work correctly with explicit 3659: register declarations, giving a 1.3 times slower engine (on a 486DX2/66 3660: running the Sieve) than the one measured above. 3661: 1.24 ! anton 3662: The numbers in this section have also been published in the paper ! 3663: @cite{Translating Forth to Efficient C} by M. Anton Ertl and Martin ! 3664: Maierhofer, presented at EuroForth '95. It is available at ! 3665: @*@file{}; ! 3666: it also contains numbers for some native code systems. You can find ! 3667: numbers for Gforth on various machines in @file{Benchres}. ! 3668: 1.4 anton 3669: @node Bugs, Pedigree, Internals, Top 3670: @chapter Bugs 3671: 1.17 anton 3672: Known bugs are described in the file BUGS in the Gforth distribution. 3673: 1.24 ! anton 3674: If you find a bug, please send a bug report to ! 3675: @code{gforth-bugs@@mips.complang.tuwien.ac.at}. A bug report should 1.17 anton 3676: describe the Gforth version used (it is announced at the start of an 3677: interactive Gforth session), the machine and operating system (on Unix 3678: systems you can use @code{uname -a} to produce this information), the 1.24 ! anton 3679: installation options (send the @code{config.status} file), and a ! 3680: complete list of changes you (or your installer) have made to the Gforth ! 3681: sources (if any); it should contain a program (or a sequence of keyboard ! 3682: commands) that reproduces the bug and a description of what you think ! 3683: constitutes the buggy behaviour. 1.17 anton 3684: 3685: For a thorough guide on reporting bugs read @ref{Bug Reporting, , How 3686: to Report Bugs, gcc.info, GNU C Manual}. 3687: 3688: 1.4 anton 3689: @node Pedigree, Word Index, Bugs, Top 3690: @chapter Pedigree 3691: 1.17 anton 3692: Gforth descends from BigForth (1993) and fig-Forth. Gforth and PFE (by 1.24 ! anton 3693: Dirk Zoller) will cross-fertilize each other. Of course, a significant ! 3694: part of the design of Gforth was prescribed by ANS Forth. 1.17 anton 3695: 1.23 pazsan 3696: Bernd Paysan wrote BigForth, a descendent from TurboForth, an unreleased 3697: 32 bit native code version of VolksForth for the Atari ST, written 3698: mostly by Dietrich Weineck. 3699: 3700: VolksForth descends from F83. It was written by Klaus Schleisiek, Bernd 3701: Pennemann, Georg Rehfeld and Dietrich Weineck for the C64 (called 1.24 ! anton 3702: UltraForth there) in the mid-80s and ported to the Atari ST in 1986. 1.17 anton 3703: 3704: Laxen and Perry wrote F83 as a model implementation of the 3705: Forth-83 standard. !! Pedigree? When? 3706: 3707: A team led by Bill Ragsdale implemented fig-Forth on many processors in 1.24 ! anton 3708: 1979. Robert Selzer and Bill Ragsdale developed the original ! 3709: implementation of fig-Forth for the 6502 based on microForth. ! 3710: ! 3711: The principal architect of microForth was Dean Sanderson. microForth was ! 3712: FORTH, Inc.'s first off-the-shelf product. It was developped in 1976 for ! 3713: the 1802, and subsequently implemented on the 8080, the 6800 and the ! 3714: Z80. 1.17 anton 3715: 1.24 ! anton 3716: All earlier Forth systems were custom-made, usually by Charles Moore, ! 3717: who discovered (as he puts it) Forth in the late 60s. 1.17 anton 3718: 3719: A part of the information in this section comes from @cite{The Evolution 3720: of Forth} by Elizabeth D. Rather, Donald R. Colburn and Charles 3721: H. Moore, presented at the HOPL-II conference and preprinted in SIGPLAN 3722: Notices 28(3), 1993. You can find more historical and genealogical 3723: information about Forth there. 3724: 1.4 anton 3725: @node Word Index, Node Index, Pedigree, Top 3726: @chapter Word Index 3727: 1.18 anton 3728: This index is as incomplete as the manual. Each word is listed with 3729: stack effect and wordset. 1.17 anton 3730: 3731: @printindex fn 3732: 1.4 anton 3733: @node Node Index, , Word Index, Top 3734: @chapter Node Index 1.17 anton 3735: 3736: This index is even less complete than the manual. 1.1 anton 3737: 3738: @contents 3739: @bye 3740: | http://www.complang.tuwien.ac.at/cvsweb/cgi-bin/cvsweb/gforth/Attic/gforth.ds?annotate=1.24;sortby=log;f=h;only_with_tag=MAIN;ln=1 | CC-MAIN-2020-05 | refinedweb | 27,618 | 63.29 |
Problem category: Compile-Time Problem
Diagnosis Difficulty: Easy
Difficulty to Fix: Easy
This problem usually occurs when you're trying to perform calculations using floating point numbers and then storing the results into an integer data type. Java has no problem promoting the data type of a value implicitly, however the designers decided that because an implicit demotion/down cast is likely an accident, the programmer must explicitly specify that's what they want.
The promotion diagram for Java data types looks like (follow the arrows for implicit promotions/casts):
` byte v short v int v long v float v double v boolean > String < Object < Polymorphic object ^ char
So for example, a byte can be implicitly cast to a short, but a short cannot be implicitly cast to a byte. The most common problems for beginners is dealing with casting of primitive types (particularly between floating point data types and integer data types).
Examples of some bad casts:
// simple examples // 1 int a = 5.5; // casting from double to int // 2 long b = 1; int c = b; // casting from long to int // 3 double d = 3; int e = d; // casting from double to int // more complex/subtle examples // 4 double f = 5; int g = 1 + 3 * b; // casting from double to int // 5 short h = 3; // casting from int to short // 6 float i = 3.5; // casting from double to float byte
Suggested fixes
For most cases (especially those involving number data types) you can usually specify an explicit cast. This is done by placing the type name in parenthesis, then an expression you want casted after that.
int a = (int) 5.5; // 5.5 is explicitly cast into an int, a=5
Note that when dealing with polymorphic objects and casting them down the inheritance chain will still perform type checking. For example:
public class Base {} public class Derive1 extends Base {} public class Derive2 extends Base {} //... Base a = new Derive1(); Derive2 b = (Derive1) a; // technically should compile, however on runtime you'll get a ClassCastException. You'll probably even get a warning saying this is an unsafe cast.
In the above example, the compiler cannot determine if a is a Derive1 object, a Derive2 object, or something else entirely.
Additionally, sometimes a cast demotion does not exist, even though a promotion cast does exist (for example a String to an int).
int a = (int) "5"; // invalid, there's no cast for a String to an int, implicit or explicit
In these cases, you have 2 options:
1. Search for a method which performs the desired option you want
Number constants
The last major problem when dealing with casts are number constants.
float a = 3.5; // 3.5 is actually a double literal, invalid implicit cast int b = 3L; // 3 is actually a long literal, invalid implicit cast byte c = 256; // out of the range for a byte, treated as an int literal, invalid implicit cast
There are two solutions to this problem:
1. Use the "general" solution of specifying an explicit cast.
float a = (float) 3.5; int b = (int) 3L; byte c = (byte) 256;
byte - none (must be in the range of a byte)
short - none (must be in the range of a short)
int - none (must be in the range of an int)
long - 'L' (must be in the range of a long)
float - 'f'
double - none
float a = 3.5f; int b = 3; long c = 1000000000000L; // there's no appropriate equivalent for this case since it's basically a guaranteed loss of precision // byte c = 256; | http://www.javaprogrammingforums.com/content/23-common-java-mistakes-type-mismatch-invalid-cast.html | CC-MAIN-2015-27 | refinedweb | 590 | 54.76 |
You need to add a touch of Machine Learning in your viz Tableau ? You do not know how ? this tutorial has been designed to help you better understand and use the possibilities of Tableau on integrating Python scripts. So have your keyboards and follow the guide …
TabPy architecture
TabPy is a server. It is in fact a gateway that will allow communication between Tableau and the Python world. This server must therefore be started so that Tableau can pass Python requests (commands).
Note that what will be exposed here with Python is just as true for R (except that R has its server natively: RSERVE).
Installing TabPy
It all starts with the installation of the server (TabPy) provided by Tableau for free via Github. So start by downloading the TabPy project .
Then you will need Python (if it is not already installed on your machine). Personally I will recommend using the Anaconda distribution (free too) which you can also download here .
Let’s summarize the steps:
- Install Anaconda on your machine or server.
- Create a specific environment via Anaconda Navigator in Python 3.6, like below:
- Add the modules / libraries you need (scikit-learn, pandas, etc.)
- Unzip TabPy (downloaded previously) into an accessible directory.
- Launch a command line (shell)
- Activate the environment you created earlier using the activate (anaconda) command
- Go to the TabPy directory
- Run the startup.cmd or startup.sh command
$ activate tableau $ cd /tools/TabPy $ startup.sh
Normally your server should start and wait for requests. If you have a problem it is probably due to missing modules, library problems (make sure you are on the right environment), or other. In short, in case of problems go to the TabPy readme
First test with Desktop
Our TabPy server is launched. We will now open a Tableau Desktop and start with a viz and a very simple Python function. We will have first names as data and we will simply concatenate them with a fixed string in a Python function. Here is the function in question:
lst= [] for i in range(0,len(_arg1)) : lst.append(_arg1[i]+', Hello from Python (direct)!') return lst
To use it directly in Tableau Desktop we will have to create a calculated field in which we will embed this code. We will then use (depending on the data type) one of the SCRIPT_ * functions of Tableau . there are 4 SCRIPT_ * functions:
- SCRIPT_BOOL: to manage lists of bouléens
- SCRIPT_INT: to manage lists of integers
- SCRIPT_STR: to manage alphanumeric lists
- SCRIPT_REAL: to manage lists of reals
This leads us to pay attention to certain points:
- The parameters (inputs and outputs) must be uniform (no question of using lists comprising integers, reals and strings).
- The parameters that will be passed to Python (or R) must be syntaxed as follows for Python _arg # (_arg1, _arg2, etc.) and for R .arg #
- The size / format of the input & output parameters must be the same!
In Tableau Desktop we will therefore create a calculated field in which we will use the SCRIPT_STR function which will contain the previous Python function:
Here is the function to paste:
SCRIPT_STR(" lst= [] for i in range(0,len(_arg1)) : lst.append(_arg1[i]+', Hello from Python (direct)!') return lst ", ATTR([Col1]) )
Now drag and drop the new calculated field into a row for example and see the result (see above)
Deploy functions
I know what you’re going to say: Ok it’s nice to be able to wrap some Python code in calculated fields. But it will quickly become unmanageable if I have to call a lot of code! and how to use an already trained Machine Learning model? Fortunately Tableau allows you to deploy functions on the TabPy server. This makes it possible to simplify the SCRIPTS calls but also and above all to facilitate their maintenance. Let’s see how it works.
First let’s create our function using Python directly or via Jupyter Notebook ( code here ):
import tabpy_client toConcatenate = ", Hello from Python ! (deployed)" def hello_python(_arg1): lst= [] for i in range(0,len(_arg1)) : lst.append(_arg1[i] + toConcatenate) return lst client = tabpy_client.Client('') client.deploy('hello_python', hello_python, 'This is a simple Python call', override=True)
We find of course the hello_python () function but also and especially the connection to the TabPy server via tabpy_client.Client () and the deployment of the function via the deploy () method
Once the code is executed, the hello_python (_arg1) function can be used directly by the TabPy server. The call via Desktop is then considerably simplified:
Here is the simplified code:
SCRIPT_STR("return tabpy.query('hello_python',_arg1)['response']", ATTR([Col1]) )
Instead of the function code we now have a call to TabPy’s registers (endpoints) to retrieve the function and call it.
In this regard you can see the list of all the functions deployed on your server by typing in your browser: http: // localhost: 9004 / endpoints
There you have it, you have seen how to simply install and use TabPy, I now encourage you to go to the official documentation for more information. You can also find a lot of information on the Tableau forums (eg here ).
There you have it, you have seen how to simply install and use TabPy, I now encourage you to go to the official documentation for more information. You can also find a lot of information on the Tableau forums (eg here ).
As usual you will find the sources for this mini-tutorial on GitHub . | http://aishelf.org/tabpy/ | CC-MAIN-2021-31 | refinedweb | 908 | 62.78 |
I’ve been working on wrapping PyGTK around a podcast grabbing Python script that I wrote. You can take a glance at the code that actually does the work here. The posted code, particularly the configuration management, is really tightly coupled to all other parts of the app. Also, the download manager expects much more information than it should in an odd data type comprised of a dictionary and an elementtree object. I’ve removed some of those warts in the version I’m currently working on.
Anyway, I’ve been working on wrapping PyGTK around the above-mentioned script and have finally gotten something that sort of works. One of the minor annoyances, though, is that when I click on a button that tells the app to show me which podcasts are available for download, the app freezes up until it has figured out every last available download. Even though I have code to update the status bar in the method which handles this button press, the only way I can figure out if anything is going on is to look at the terminal window I started the podgrabber app from.
Since I have the app somewhat functional, I decided to fix this blocking annoyance. The reason that this GUI app is behaving like this is that when the application is launched, it is being controlled by a single thread of execution. When you click on any button, that single thread of execution has to run code to perform any actions associated with that button click event. Subsequently, all other activity handling is blocked until the main thread returns from handling the current request.
So, a fix is to allow the main thread of execution to spawn a new thread to handle the button click event. Here is the code that currently executes when the “show downloads” button is clicked:
def OnShowDownloads(self, widget): status_bar = self.wTree.get_widget("mainStatusbar") self.downloadList.clear() for feed_url in self.controller.get_available_feeds(): feed_name = self.config.Feeds[feed_url]["name"] mode = self.config.Feeds[feed_url]["mode"] status_bar.push(1, feed_name)") self.downloadList.append([feed_name, dl_url, length, file_type, mode, title]) status_bar.push(1, "%s - Done" % feed_name)
Adding threading support here was pretty easy. I simply had to add “gtk.gdk.threads_init()” at the beginning of the program, create a threading decorator, apply the threading decorator to the event handler, and strategically sprinkle “gtk.threads_enter()” and “gtk.threads_leave()” throughout the affected code. Here is the decorator that I created:
def threaded(f): def wrapper(*args): t = threading.Thread(target=f, args=args) t.start() return wrapper
And here is the slightly modified handler method:
@threaded def OnShowDownloads(self, widget): gtk.threads_enter() status_bar = self.wTree.get_widget("mainStatusbar") self.downloadList.clear() gtk.threads_leave() for feed_url in self.controller.get_available_feeds(): feed_name = self.config.Feeds[feed_url]["name"] mode = self.config.Feeds[feed_url]["mode"] gtk.threads_enter() status_bar.push(1, feed_name) gtk.threads_leave()") gtk.threads_enter() self.downloadList.append([feed_name, dl_url, length, file_type, mode, title]) gtk.threads_leave() gtk.threads_enter() status_bar.push(1, "%s - Done" % feed_name) gtk.threads_leave()
Twisted integrates with the gtk event loop quite easily.
You wouldn't need to use threads for something like this
since it's completely IO bound.
Cary,
I had seen that about Twisted and gtk. Currently, I'm using urllib to pull down the podcasts, but had considered switching to Twisted for that, so using it in other places should come pretty easily. I wouldn't include Twisted just to avoid using threads for the GUI, but if I were already using it elsewhere, I'd likely do it.
Hi all!
Where it is possible to find out about high school diploma?
You can find out about high school diploma by not flunking out you failure. | http://www.oreillynet.com/onlamp/blog/2006/07/pygtk_and_threading.html | crawl-002 | refinedweb | 619 | 57.98 |
Fake it!
Fake It!
A couple of tools to generate fake data in your app.
Hi, this time I want to talk about a couple of tools to generate fake data for your app. It is not my intention to dig deep into the controversy of data generators versus creating unique values using sequences, maybe we can leave that for another post, as of today I'd like to show you how to work with fake data.
The first one to review is the gem Forgery. Using Forgery is pretty straightforward:
If you want to give at try in your irb console:
$ gem install forgery
and require it on the console:
irb(main):004:0> require 'forgery'
you can now play with it:
irb(main):005:0> Forgery(:basic).password => "XsTWTcFIuLG"
If you prefer, you can also write it like this:
# instead of: Forgery(:basic).password # try with: Forgery::Basic.password # instead of: Forgery(:name).full_name # try with: Forgery::Name.full_name …
If you want to use Forgery in your app, you just need to add it to your Gemfile
gem 'forgery', '0.5.0'
One of the coolest things about forgery is that you can write your own dictionaries and formats. This is accomplished by overriding or adding entries to the default dictionaries in the gem.
Once you have installed the gem in your Rails App, run this command:
$ [bundle exec] rails generate forgery … Creating directories in /lib/forgery...
This will generete a series of directories inside '/lib/forgery'. These directories are the ones where you will add your custom forgeries (dictionaries, class extensions, formats).
/lib/forgery/dictionaries /lib/forgery/extensions /lib/forgery/forgeries /lib/forgery/formats
Let's say that we want to add a new Forgery class i.e Forgery::Pet.pet_name, first thing we need to do it's to create a pet.rb file inside /lib/forgery/forgeries and write the new class we want to add:
class Forgery::Pet < Forgery def self.pet_name dictionaries[:pet_names].random.unextend end end
Next we need to add the new dictionary file pet_names (no extension) inside /lib/forgery/dictionaries in this file we are creating the list of pet names:
Jagger Suri Chicken Max Ruby
And that's it, now you can use it like any other Forgery class:
Forgery::Pet.pet_name
Another popular tool for fake data generation is the gem Faker. Faker is "a port of Perl's Data::Faker library that generates fake data.", according to their creators.
The usage of this gem is pretty similar to the previous one, for example, if we want to try it on a console, just run:
$ gem install faker
Next open your irb console and try it out:
irb(main):004:0> require 'faker' irb(main):005:0> Faker::Name.name => "Jameson Jewess MD"
To use it in your app, just add it to your Gemfile and run Bundle:
gem 'faker'
The customization in Faker is not as straightforward as in Forgery, and the documentation doesn't help much, after playing with the gem for a while I finally made it work.
Faker uses the i18n locals translations, with that in mind, let's say that you want to customize an existing dictionary, i.e you want to change the state abbreviations for the address dictionary.
To accomplish this, you need to create a new file in your locals folder like this: /config/locals/custom_abbr.yml (you can use your default en.yml local file).
en: faker: address: state_abbr: [CAL, FLO, TEX]
And use the new definitions as usual:
irb(main):001:0> Faker::Address.state_abbr => "TEX"
In another example, let's say that you need to create a completely new custom class, not included in the Faker gem, city abbreviations for example. So, for this you'll need to define your new class, I called mine address_extended and defined it in a new lib file with the Faker namespace, lib/faker/ in this file we are going to define our class method:
class Faker::AddressExtended < Faker::Base def self.city_abbr fetch('address_extended.city_abbr') end end
You will need to require this file in a initializers/faker.rb file
require 'faker/address_extended'
And last but not least, add your custom yml translations:
en: faker: address_extended: city_abbr: [LIX, NYC, SFO]
Now you can use your new Faker class:
irb(main):001:0> Faker::AddressExtended.city_abbr => "SFO"
So there you go, two good tools to generate fake data into your app. Keep in touch because in the next post I would like to discuss about the performance of this two gems, including ffaker, which includes the functionality of Faker and adds more to it, and also works a little bit faster.
Remember to post your comments and experiences!!
Happy Faking! | http://blog.magmalabs.io/2013/08/16/fake-it.html | CC-MAIN-2021-04 | refinedweb | 789 | 60.65 |
Working with µObjects at work and in the examples I've been experimenting with; I've found a recurring conflict of principles.
In the early days of learning actual Object Oriented Programming with Fred George we were hammered with "What's it's job?"! This is beaten into my head pretty well.
If an object has no behavior - it has no reason to exist.
Using the Pizza Kata
Topping as the basis for this discussion.
Looking through the history of this file; we can see some of the variations; but we'll start with the base and discuss from there.
public class Topping : ITopping { private readonly string _name; private readonly double _percentage; private Topping(string name, double percentage) { _name = name; _percentage = percentage; } public Money Cost(Money pizzaCost) => pizzaCost % _percentage; public IText Name() => new TextOf(_name); } public interface ITopping { Money Cost(Money pizzaCost); IText Name(); }
With this; if I want to have a Mushroom topping; how do I do it?
Constructor Style
The stye that µObjects wants to use is the following
public class Mushroom : Topping { public Mushroom() : base("Mushroom", .1) }
This screams in agony to me. The class has no behavior! It ... does nothing! The horror!
I'm against this - it's... empty and devoid of behavior.
Abstract Methods
The next version I've worked with; and is in a number of classes at work; is to use abstract methods.
public class Topping : ITopping { public Money Cost(Money pizzaCost) => pizzaCost % Percentage(); public IText Name() => new TextOf(Type()); protected abstract double Percentage(); } public class Mushroom : Topping { protected override string Type() => "Mushroom"; protected override double Percentage() => .1 }
This way the
Mushroom has a little behavior... ish. There's no public behavior. If there's no behavior... why does it exist?
(Note: We're ignoring that Name could be abstract and implemented in Mushroom for this discussion)
Caller Knows
We could force the knowledge on the caller...
new Topping("Mushroom", .1);
... But... uhh... That's spreading a bunch of
const information all over. We're either having things hard coded and decreasing maintainability or adding public constants which... bleh. We don't use public constants.
This just doesn't work. It's a point that has been discussed, and has handidly been ruled out. If you want to do this to your code base - you're cruel.
Static Slugs
As has been done in the Pizza Kata, static slugs in
Topping.
public static readonly ITopping Mushroom = new Topping("Mushroom", RegularPercentage);
This can work. Only if the object can exist as a single instance. This is nice because it hides how the object is instantiated.
A downside is that Topping now has quite a few reasons to change. The Description changes, the percentage changes, toppings added, toppings removed... This is a lot of reasons to change; and very much does not limit the scope of change - a key to maintainable code.
Slugs can work; They are critical to how Quantity and Conversion work. But it's not the correct choice everywhere. It's working (ish) in the Pizza kata; but it violates the princple of limiting the scope of change.
I don't like it, and what if we can't use the same instance everyhere?
Factory Methods
We could have methods on
Topping that returns new instances for us instead of slugs
public class Topping : ITopping{ public static ITopping Mushroom() => new Topping("Mushroom", .1); }
This doesn't get us around the scope of change issue. Topping becomes a bit of a bloated and god-like class. It's horrible. It smells... It's static methods - Which we don't like static methods. Way too tightly couples things.
How do we get away from this horrible smell in the code.
Factory Object
There's two kinda factories I'm thinking about for thia. We can use a proper Factory class
public class ToppingFactory : IToppingFactory{ public ITopping Create(...)... }
But what the hell do we pass into the Create method? An enum? Gah - No. That's just asking for bad code to be written.
We could do specific functions
public class ToppingFactory{ public ITopping CreateMushrooms() => new Topping("Mushroom", .1); }
But then ... Ehh... We're starting to use factories. I feel factories are a symptom of a failed design. If you need a factory; your design has failed. It's not a good Object Oriented design. You should refactor until the factory isn't needed... Oh - Wait - That's exactly what we're trying to figure out how to do here!
Duplicate Code
We can simply duplicate the limited code.
public class Mushroom : ITopping { public Money Cost(Money pizzaCost) => pizzaCost % .1; public IText Name() => new TextOf(Mushroom); }
These types of classes in µObjects are going to be small. It's not a lot of code to be repeated. The downside here is that this is actually creating duplication. The code would change for the same reason. Each type of topping would need to be modified if the
Cost calculation changed.
Duplication of Intent is bad - and this path creates A LOT of it. We can't allow that.
What to Do?
What do we do? I assume there's other options I'm missing; but this is all things we've discussed at work and I've explored through projects.
I had a discussion at lunch today which has actually clarified the best of these options.
It's the first one presented; passing the values to the base class.
public class Mushroom : Topping { public Mushroom() : base("Mushroom", .1) }
Why are we accepting the empty class? The behaviorless abomination!
Because it does a thing.
This class does one thing; it knows one thing. It owns the information for the
Mushroom topping.
We see something similar using the Chain of Responsibility; there's one clas that just knows how to construct the chain. This just knows how to construct the mushroom.
It looks really wrong. Just seeing it, my OOP sense screams - But... It is the µObject way. Do A Thing.
This is an aspect that I think deviates from other OOP style of development.
Summary
We've looked at a lot of ways we can instantiate objects that all use a shared behavior. They all have a smell, but the least smelly, most µObject style is to have an empty class that does one thing - provides the correct values. It's a very important task as we can see, and if it's not done properly; it'll harm the maintainability of the code.
My preferred options are going to be the Constructor style or Slugs when it's reasonible. Though I'm inclined to avoid the slugs unless there's a really good justification for it. | https://quinngil.com/2018/03/26/microobjects-class-creation-dilemma-2/ | CC-MAIN-2021-10 | refinedweb | 1,109 | 67.55 |
compiler switch and IJ.
As I have stated previously, when native C++ code is recompiled with
/clr, the
classes don't automatically become managed and are marked
__nogc for the
reasons I cited. If your class does meet the requirements of the CLR, however,
you can make your class managed by marking it with the
__gc modifier to
indicate that it is a garbage-collected class, or the
__value modifier to
indicate that it is a CTS value type.
What if your class cannot be made managed by adding the
__gc or
__value
modifiers? You may have code that uses templates or multiple inheritance. You
may have code that uses inline assembly to reuse the functionality from
something you would usually inherit from that class. For obvious reasons
outlined earlier, you cannot inherit a managed class from an unmanaged one, and
vice versa. So what do you do if you want to reuse the functionality? For
problems like this, the general solution is to either "aggregate" or "embed a
pointer." Without going into a lot of low-level details, aggregating an
unmanaged class within a managed one causes a lot of problems, and the compiler
cannot convert an object from the
fc heap to a non-GC reference. The way to do
this is to embed a pointer to an unmanaged type within the managed class. It
looks something like this (a contrived example):
; pContainer->SetValue(&someValue); } ~ManagedContainer() { delete pContainer; } }; void main() { ManagedContainer *mc = new ManagedContainer(); int someValue = 42; mc->SetValue(someValue); System::Console::WriteLine("The value is ", someValue.ToString()); }
In this solution, I create an embedded pointer to the the unmanaged class type
Container inside
ManagedContainer and control it explicitly. Will this code
work? Perhaps sometimes, but there is a big problem with the code as it stands.
The problem is that the CLR, in its GC, moves object references around. This
is not a problem until such a reference is passed to an unmanaged function or
used in an unmanaged object. The CLR has no way to keep track of the reference
once it transitions to unmanaged code. So in order to prevent the value from
getting corrupted, we need to "pin" the pointer using the
__pin keyword:
; int __pin* pinnedInt = &someValue; pContainer->SetValue(pinnedInt); } ~ManagedContainer() { delete pContainer; } }; void main() { ManagedContainer *mc = new ManagedContainer(); int someValue = 42; mc->SetValue(someValue); System::Console::WriteLine("The value is ", someValue.ToString()); }
This type of approach leads to the ability to wrap your C++ code with managed wrappers, enabling your C++ code to be used from other managed languages like C# and VB.NET. I will explore more of this in detail, in the next article of this series.
Now, what if we want to go the other way? That is, use managed types from unmanaged code?
Managed types cannot directly be used from unmanaged types. This is again
related to the fact that the CLR must keep track of object references to implement
garbage collection. What if we did want to use an object reference in an unmanaged
type? The CLR provides a type,
System::Runtime::InteropServices::GCHandle, that
treats object references as integers from unmanaged code. The technique for
using this function is quite simple: call
GCHandle::Alloc() to generate a handle
and
GCHandle::Free() to free it.
However, this pattern can get quite messy, so there is a better way. In the file
gcroot.h, the VC++ team has provided a smart pointer, called
gcroot<>, to
simplify the use of
GCHandle in unmanaged types. With this template, we are
able to use a
System::String in an unmanaged class, like so:
#using <mscorlib.dll> #include <vcclr.h> using namespace System; class CppClass { public: gcroot<String*> str; // can use str as if it were String* CppClass() {} }; int main() { CppClass c; c.str = new String("hello"); Console::WriteLine( c.str ); // no cast required }
In this article, I have only scratched the surface of what's possible. The next step is to further look at what IJW accomplishes and where it falls short, and how to make functions managed, how to make your data managed, and how to write managed wrappers around unmanaged functions.
Sam Gentile is a well-known .NET consultant and is currently working with a large firm, using Visual C++ .NET 2003 to develop both unmanaged and managed C++ applications.
Return to ONDotnet.com | http://archive.oreilly.com/lpt/a/3226 | CC-MAIN-2016-40 | refinedweb | 725 | 54.42 |
One request we always seem to come across as developers is “Can we have a version of the page avaliable as a Word Document?”. With traditional ASP.Net this is easy. Simply place something similar to the following code block in your Page_Load.
Response.Clear(); Response.Buffer = true; Response.ContentType = "application/ms-word"; StringWriter stringWriter = new StringWriter(); HtmlTextWriter htmlTextWriter = new HtmlTextWriter(stringWriter); this.RenderControl(htmlTextWriter); Response.Write(stringWriter.ToString()); Response.End();
And that was it. Now using Asp.Net MVC it isn’t that simple. We somehow need to return this data in the form of an ActionResult. I did this by creating: 2 Controllers 1 View and 1 new ActionResult Class.
First the 2 Views: DetailedReport and DetailedReportWord.
/// <summary> /// This view is used to display the web version of the report as a web page in the users browser /// This Controller has a View named DetailedReport /// <summary> public ActionResult DetailedReport() { //[...] return View(); } /// <summary> /// This view is used convert the DetailedReport view into a Word Document and send it to the user /// This Controller does not have an associated View /// <summary> public ActionResult DetailedReportWord() { RouteValueDictionary rvd = new RouteValueDictionary(); string url = Url.Action("DetailedReport", "Reports", rvd, "http"); return new WordActionResult(url, "detailed-report.doc"); }
Now for the new ActionResult Class: WordActionResult. This class will take a URL and execute a HttpRequest. The resulting content is then streamed to the users as a Word Document
using System; using System.Collections.Generic; using System.IO; using System.Linq; using System.Net; using System.Text; using System.Web; using System.Web.Mvc; using System.Web.UI; namespace Revium.Utilities.MVC { public class WordActionResult : ActionResult { private string _url; public string url { get { return _url; } } private string _filename; public string fileName { get { return _filename; } } public WordActionResult(string pUrl, string pFileName) { _url = pUrl; _filename = pFileName; } public override void ExecuteResult(ControllerContext context) { HttpContext curContext = HttpContext.Current; curContext.Response.Clear(); curContext.Response.AddHeader("content-disposition", "attachment;filename=" + _filename); curContext.Response.Charset = ""; curContext.Response.Cache.SetCacheability(HttpCacheability.NoCache); curContext.Response.ContentType = "application/ms-word"; HttpWebRequest wreq = (HttpWebRequest)HttpWebRequest.Create(_url); // If we are using forms authentication we need to get the .ASPXAUTH cookie and add it to our request var httpCookie = context.HttpContext.Request.Cookies[".ASPXAUTH"]; wreq.CookieContainer = new CookieContainer(); wreq.CookieContainer.Add(new Cookie(httpCookie.Name, httpCookie.Value, httpCookie.Path, context.HttpContext.Request.Url.Host)); HttpWebResponse wres = (HttpWebResponse)wreq.GetResponse(); using (Stream s = wres.GetResponseStream()) { using (StreamReader sr = new StreamReader(s, Encoding.ASCII)) { curContext.Response.Write(sr.ReadToEnd()); curContext.Response.End(); } } } } }
Now you may notice that ExecuteResult is a little different to the example i gave right at the start. This is because we are not converting the current view to a Word document. We are using the DetailedResultWord Controller to convert DetaileResult to a Word document.
This is just a very simple implementation but it has certainly given us the stepping stones required to convert MVC Views to Word and Excel documents.
Related posts:
Very nice idea. Thanks for sharing. This approach might be used for other types of dynamically generated files e.g. pdf files.
good articles, Microsoft does not recommend using Office application in server-side scenarios, I recommand use Spire.Doc without ole automation.
Thanks for the tip Haydee. This isn’t using Office server side though. It is just telling the browser to use Word to open the HTML document
Cannot get this to work.
how id it that you are calling “WordActionResult.Word” when your class does not contain it? This would be extremely useful if I could get it to work Any help would be great. Thanks
@Michael You may be having an issue resolving the namespace. You will either need to add a Using statement to the top of your page
Or call it using the fully qualified name
I am with Michael Franklin
I don’t see how this will work, there is nothing in the WordActionResult call “Word”,
Even when you include the namespace, there is nothing in that class called word.
How can you reference something that is not there? intellisense doesn’t recognize word either???
@TWal Yeah i can see the problem now. I had posted my original controller with my newer WordActionResult. I have updated the code above. For quick reference we need to change:
return WordActionResult.Word(url, “detailed-report.doc”);
to
return new WordActionResult(url, “detailed-report.doc”);
Hope it helps
Nice technique.
Any idea how to pass the authorised credentials over in the webrequest? the response I get back is my login page
@Jim I’m not sure why this would happen for you. Make sure you use the same Authorize attribute settings on the DetailedReportWord action result or location elements in your web.config files
Hi Mark,
Thanks for the post, this is similar to what I am looking to do in my project. I was able to implement this as you have directed. Now what I am trying to achieve is I need to do this in an AJAX call. On my view there is a button, clicking on which I need to build the model and give it to the user to save as a Word Document. The flow works fine but I guess I will need to change the resulting view which I am not sure how to do. I am new to MVC, could you please point me to the right direction?
Thanks,
Chitrang
@Chitrang I’ve never had to do this via AJAX before and at a glance I’m not sure if it is possible. This method relies on changing the Response Header and Content type. Your best option might be: use an AJAX request to update some data at the server and then open a new browser window calling DetailedReportWord with some sort of identifier
Hi Mark,
Thanks for the prompt response. I have scrapped the idea of using AJAX call for this, I have created the same model in my application as you have suggested.
Now the problem that I have is when the WebRequest is initiated it gets thrown to the Login page and what I get in the response is my Login page HTML. This is due to the rule we have setup for our application that without logging in, no one can access any page with just the URL. Is there a way to get around this issue?
There is something called FileStreamResult or FileContentResult, can one of these be used instead?
Thanks,
Chitrang
@Chitrang. I think you are going to have to allow access to at least 1 URL for this to work. Good luck
Thanks Mark. I am looking for other solutions and if I cant get them to work we may end up having one exception for this in our application rules.
Hi Mark,
Nice neat article. I want to know how can i get the images from my HTML to pull through onto the word doc?
@Rampersahd The only way to get images to be included using this technique is to make sure the src is the fully qualified URL. i.e. src=”” not src=”../../Content/img.jpg”
The downside to this is that each time someone opens the document they will actually re-dowload the image from your site. If this is not acceptable you might need to look at server side options like @Haydee Velaquez suggested
Hi Mark,
I’m trying to use your approach to return a view as ms-word. The problem is, the view is required parameters to populate the view with correct data.
Is there any idea to do it? Really2 need help/idea to accomplish this. I’ve tried to put the url with parameter, buts it seem not populating it.
And also, when i try to run this at local, it can return as a ms-word if the url is not localhost. If localhost, it will return remote server (500) error.
Thanks in advance.
@Kimi.
This was just a basic implementation. You can change your URL and add parameters to your views fairly easily. To help put you on the right track I have updated the example to use a more dynamic url
string url = Url.Action(“DetailedReport”, “Reports”, rvd, “http”);
If you add the same route values to both action results you can pass them from the DetailedReportWord action by updating the RouteValueDictionary before calling DetailedReport
Hi Mark!
I have one problem with code.
This part: ‘ string url = Url.Action(“DetailedReport”, “Reports”, rvd, “http”); ‘
Displays an error message ‘Action is not member of the String’. How can I do?
Thank you.
@Pryscila: Are you using a stnadard MVC project? Does Url.Action auto complete via IntelliSense when you type? Url is a UrlHelper and it is a property of Controller and should work.
Hello Mark, thank you for the reply. It worked! The problem is that the generated word is not my view, but the login page of the project.
You know how I can fix this?
Thank you.
@Pryscila You need to make sure that the Action is accessible by the logged in user
I noticed that there is a redirect to the login page. Even he transfers to Word file to. CSS that is not recognized by Word. You know how I can pass the authentication?
Thank you.
Hi Mark
Thank you for this article, I have been using the code for a while and it works very well.
Do you know if there is an easy way to tell word to open in Landscape mode?
Thanks
Greg
hello..is it possible to return word (.docx) file. I tried to convert to docs file. File is created but while try to open the file showing the message that “file is corrupted”. | http://www.revium.com.au/articles/sandbox/aspnet-mvc-convert-view-to-word-document/comment-page-1/ | CC-MAIN-2014-42 | refinedweb | 1,616 | 58.58 |
Question:
How would you implement a capacity-limited, generic MruList in C# or Java?
I want to have a class that represents a most-recently-used cache or list (= MruList). It should be generic, and limited to a capacity (count) specified at instantiation. I'd like the interface to be something like:
public interface IMruList<T> { public T Store(T item); public void Clear(); public void StoreRange(T[] range); public List<T> GetList(); public T GetNext(); // cursor-based retrieval }
Each Store() should put the item at the top (front?) of the list. The GetList() should return all items in an ordered list, ordered by most recent store. If I call Store() 20 times and my list is 10 items long, I only want to retain the 10 most-recently Stored items. The GetList and StoreRange is intended to support retrieval/save of the MruList on app start and shutdown.
This is to support a GUI app. I guess I might also want to know the timestamp on a stored item. Maybe. Not sure.
Internally, how would you implement it, and why?
(no, this is not a course assignment)
Solution:1
Couple of comments about your approach
- Why have Store return T? I know what I just added, returning it back to me is un-necessary unless you explicitly want method chaining
- Refactor GetNext() into a new class. It represents a different set of functionality (storage vs. cursor traversal) and should be represented by a separate interface. It also has usability concerns as what happens when two different methods active on the same stack want to traverse the structure?
- GetList() should likely return
IEnumerable<T>. Returning
List<T>either forces an explicit copy up front or returns a pointer to an underlying implementation. Neither is a great choice.
As for what is the best structure to back the interface. It seems like the best to implement is to have a data structure which is efficient at adding to one end, and removing from the other. A doubly linked list would suit this nicely.
Solution:2
Here's a Cache class that stores objects by the time they were accessed. More recent items bubble to the end of the list. The cache operates off an indexer property that takes an object key. You could easily replace the internal dictionary to a list and reference the list from the indexer.
BTW, you should rename the class to MRU as well :)
class Cache { Dictionary<object, object> cache = new Dictionary<object, object>(); /// <summary> /// Keeps up with the most recently read items. /// Items at the end of the list were read last. /// Items at the front of the list have been the most idle. /// Items at the front are removed if the cache capacity is reached. /// </summary> List<object> priority = new List<object>(); public Type Type { get; set; } public Cache(Type type) { this.Type = type; //TODO: register this cache with the manager } public object this[object key] { get { lock (this) { if (!cache.ContainsKey(key)) return null; //move the item to the end of the list priority.Remove(key); priority.Add(key); return cache[key]; } } set { lock (this) { if (Capacity > 0 && cache.Count == Capacity) { cache.Remove(priority[0]); priority.RemoveAt(0); } cache[key] = value; priority.Remove(key); priority.Add(key); if (priority.Count != cache.Count) throw new Exception("Capacity mismatch."); } } } public int Count { get { return cache.Count; } } public int Capacity { get; set; } public void Clear() { lock (this) { priority.Clear(); cache.Clear(); } } }
Solution:3
I would have an internal ArrayList and have Store() delete the last element if its size exceeds the capacity established in the constructor. I think standard terminology, strangely enough, calls this an "LRU" list, because the least-recently-used item is what gets discarded. See wikipedia's entry for this.
Solution:4
You can build this up with a
Collections.Generic.LinkedList<T>. When you push an item into a full list, delete the last one and insert the new one at the front. Most operations should be in O(1) which is better than a array-based implementation.
Solution:5
Everyone enjoys rolling their own container classes.
But in the .NET BCL there is a little gem called
SortedList<T>. You can use this to implement your MRU list or any other priority-queue type list. It uses an efficient tree structure for efficient additions.
From SortedList on MSDN:.
Solution:6
In Java, I'd use the
LinkedHashMap, which is built for this sort of thing.
public class MRUList<E> implements Iterable<E> { private final LinkedHashMap<E, Void> backing; public MRUList() { this(10); } public MRUList(final int maxSize) { this.backing = new LinkedHashMap<E,Void>(maxSize, maxSize, true){ private final int MAX_SIZE = maxSize; @Override protected boolean removeEldestEntry(Map.Entry<E,Void> eldest){ return size() > MAX_SIZE; } }; } public void store(E item) { backing.put(item, null); } public void clear() { backing.clear(); } public void storeRange(E[] range) { for (E e : range) { backing.put(e, null); } } public List<E> getList() { return new ArrayList<E>(backing.keySet()); } public Iterator<E> iterator() { return backing.keySet().iterator(); } }
However, this does iterate in exactly reverse order (i.e. LRU first, MRU last). Making it MRU-first would require basically reimplementing
LinkedHashMap but inserting new elements at the front of the backing list, instead of at the end.
Solution:7
Java 6 added a new Collection type named Deque... for Double-ended Queue.
There's one in particular that can be given a limited capacity: LinkedBlockingDeque.
import java.util.ArrayList; import java.util.List; import java.util.concurrent.LinkedBlockingDeque; public class DequeMruList<T> implements IMruList<T> { private LinkedBlockingDeque<T> store; public DequeMruList(int capacity) { store = new LinkedBlockingDeque<T>(capacity); } @Override public void Clear() { store.clear(); } @Override public List<T> GetList() { return new ArrayList<T>(store); } @Override public T GetNext() { // Get the item, but don't remove it return store.peek(); } @Override public T Store(T item) { boolean stored = false; // Keep looping until the item is added while (!stored) { // Add if there's room if (store.offerFirst(item)) { stored = true; } else { // No room, remove the last item store.removeLast(); } } return item; } @Override public void StoreRange(T[] range) { for (T item : range) { Store(item); } } }
Note:If u also have question or solution just comment us below or mail us on toontricks1994@gmail.com
EmoticonEmoticon | http://www.toontricks.com/2018/05/tutorial-efficient-modelling-of-mrulist.html | CC-MAIN-2018-26 | refinedweb | 1,039 | 58.89 |
Pumpkin - Notes on handling the Perl Patch Pumpkin
There is no simple synopsis, yet.
This document attempts to begin to describe some of the considerations involved in patching and maintaining perl.
This document is still under construction, and still subject to significant changes. Still, I hope parts of it will be useful, so I'm releasing it even though it's not done.
For the most part, it's a collection of anecdotal information that already assumes some familiarity with the Perl sources. I really need an introductory section that describes the organization of the sources and all the various auxiliary files that are part of the distribution.
The Comprehensive Perl Archive Network (or CPAN) is the place to go. There are many mirrors, but the easiest thing to use is probably , which automatically points you to a mirror site "close" to you.
The mailing list perl5-porters@perl.org is the main group working with the development of perl. If you're interested in all the latest developments, you should definitely subscribe. The list is high volume, but generally has a fairly low noise level.
Subscribe by sending the message (in the body of your letter)
subscribe perl5-porters
to perl5-porters-request@perl.org .
Archives of the list are held at:..
There are no absolute rules, but there are some general guidelines I have tried to follow as I apply patches to the perl sources. (This section is still under construction.)
Never implement a specific restricted solution to a problem when you can solve the same problem in a more general, flexible way.
For example, for dynamic loading to work on some SVR4 systems, we had to build a shared libperl.so library. In order to build "FAT" binaries on NeXT 4.0 systems, we had to build a special libperl library. Rather than continuing to build a contorted nest of special cases, I generalized the process of building libperl so that NeXT and SVR4 users could still get their work done, but others could build a shared libperl if they wanted to as well.
If you are making big changes, don't do it in secret. Discuss the ideas in advance on perl5-porters.
If your changes may affect how users use perl, then check to be sure that the documentation is in sync with your changes. Be sure to check all the files pod/*.pod and also the INSTALL document.
Consider writing the appropriate documentation first and then implementing your change to correspond to the documentation.
To the extent reasonable, try to avoid machine-specific #ifdef's in the sources. Instead, use feature-specific #ifdef's. The reason is that the machine-specific #ifdef's may not be valid across major releases of the operating system. Further, the feature-specific tests may help out folks on another platform who have the same problem.
We should never release a main version without testing it as a subversion first.
We should never release a main version without testing whether or not it breaks various popular modules and applications. A partial list of such things would include majordomo, metaconfig, apache, Tk, CGI, libnet, and libwww, to name just a few. Of course it's quite possible that some of those things will be just plain broken and need to be fixed, but, in general, we ought to try to avoid breaking widely-installed things.
The embed.h, keywords.h, opcode.h, and perltoc.pod files are all automatically generated by perl scripts. In general, don't patch these directly; patch the data files instead.
Configure and config_h.SH are also automatically generated by metaconfig. In general, you should patch the metaconfig units instead of patching these files directly. However, very minor changes to Configure may be made in between major sync-ups with the metaconfig units, which tends to be complicated operations. But be careful, this can quickly spiral out of control. Running metaconfig is not really.
If you need to make changes to Configure or config_h.SH, it may be best to change the appropriate metaconfig units instead, and regenerate Configure.
metaconfig -m
will regenerate Configure and config_h.SH. Much more information on obtaining and running metaconfig is in the U/README file that comes with Perl's metaconfig units..
If you are using metaconfig to regenerate Configure, then you should note that metaconfig actually uses MANIFEST.new, so you want to be sure MANIFEST.new is up-to-date too. I haven't found the MANIFEST/MANIFEST.new distinction particularly useful, but that's probably because I still haven't learned how to use the full suite of tools in the dist distribution..
This will build a config.sh and config.h. You can skip this if you haven't changed Configure or config_h.SH at all. I use the following command
sh Configure -Dprefix=/opt/perl -Doptimize=-O -Dusethreads \ -Dcf_by='yourname' \ -Dcf_email='yourname@yourhost.yourplace.com' \ -Dperladmin='yourname@yourhost.yourplace.com' \ -Dmydomain='.yourplace.com' \ -Dmyhostname='yourhost' \ -des
[XXX This section needs revision. We're currently working on easing the task of keeping the vms, win32, and plan9 config.sh info up-to-date. The plan is to use keep up-to-date 'canned' config.sh files in the appropriate subdirectories and then generate 'canned' config.h files for vms, win32, etc. from the generic config.sh file. This is to ease maintenance. When Configure gets updated, the parts sometimes get scrambled around, and the changes in config_H can sometimes be very hard to follow. config.sh, on the other hand, can safely be sorted, so it's easy to track (typically very small) changes to config.sh and then propoagate them to a canned 'config.h' by any number of means, including a perl script in win32/ or carrying config.sh and config_h.SH to a Unix system and running sh config_h.SH.) XXX]
The Porting/config.sh and Porting/config_H files are provided to help those folks who can't run Configure. It is important to keep them up-to-date. If you have changed config_h.SH, those changes must be reflected in config_H as well. (The name config_H was chosen to distinguish the file from config.h even on case-insensitive file systems.) Simply edit the existing config_H file; keep the first few explanatory lines and then copy your new config.h below.
It may also be necessary to update win32/config.
The embed.h, keywords.h, and opcode.h files are all automatically generated by perl scripts. Since the user isn't guaranteed to have a working perl, we can't require the user to generate them. Hence you have to, if you're making a distribution.
I used to include rules like the following in the makefile:
# The following three header files are generated automatically # The correct versions should be already supplied with the perl kit, # in case you don't have perl or 'sh' available. # The - is to ignore error return codes in case you have the source # installed read-only or you don't have perl yet. keywords.h: keywords.pl @echo "Don't worry if this fails." - perl keywords.pl
However, I got lots of mail consisting of people worrying because the command failed. I eventually decided that I would save myself time and effort by manually running
make regen_headers myself rather than answering all the questions and complaints about the failing command. souce and binary compatibility with older releases of perl. That way, extensions built under one version of perl will continue to work with new versions of perl.
Of course, some incompatible changes may well be necessary. I'm just suggesting that we not make any such changes without thinking carefully about them first. If possible, we should provide backwards-compatibility stubs. There's a lot of XS code out there. Let's not force people to keep changing unordered list of aspects of Perl that could use enhancement, features that could be added, areas that could be cleaned up, and so on. During your term as pumpkin-holder, you will probably address some of these issues, and perhaps identify others which, while you decide not to address them this time around, may be tackled in the future. Update the file.
In the os2 directory is diff.configure, a set of OS/2-specific diffs against Configure. If you make changes to Configure, you may want to consider regenerating this diff file to save trouble for the OS/2 maintainer.
You can also consider the OS/2 diffs as reminders of portability things that need to be fixed in Configure..
I find the makepatch utility quite handy for making patches. You can obtain it from any CPAN archive under . There are a couple of differences between my version and the standard one. I have mine do a
# Print a reassuring "End of Patch" note so people won't # wonder if their mailer truncated patches. print "\n\nEnd of Patch.\n";
at the end. That's because I used to get questions from people asking if their mail was truncated.
It also writes Index: lines which include the new directory prefix (change Index: print, approx line 294 or 310 depending on the version, to read: print PATCH ("Index: $newdir$new\n");). That helps patches work with more POSIX conformant patch programs.
Here's how I generate a new patch. I'll use the hypothetical 5.004_07 to 5.004_08 patch as an example.
# unpack perl5.004_07/ gzip -d -c perl5.004_07.tar.gz | tar -xof - # unpack perl5.004_08/ gzip -d -c perl5.004_08.tar.gz | tar -xof - makepatch perl5.004_07 perl5.004_08 > perl5.004_08.pat
Makepatch will automatically generate appropriate rm commands to remove deleted files. Unfortunately, it will not correctly set permissions for newly created files, so you may have to do so manually. For example, patch 5.003_04 created a new test t/op/gv.t which needs to be executable, so at the top of the patch, I inserted the following lines:
# Make a new test touch t/op/gv.t chmod +x t/opt/gv.t
Now, of course, my patch is now wrong because makepatch didn't know I was going to do that command, and it patched against /dev/null.
So, what I do is sort out all such shell commands that need to be in the patch (including possible mv-ing of files, if needed) and put that in the shell commands at the top of the patch. Next, I delete all the patch parts of perl5.004_08.pat, leaving just the shell commands. Then, I do the following:
cd perl5.004_07 sh ../perl5.004_08.pat cd .. makepatch perl5.004_07 perl5.004_08 >> perl5.004_08.pat
(Note the append to preserve my shell commands.) Now, my patch will line up with what the end users are going to do.
It seems obvious, but be sure to test your patch. That is, verify that it produces exactly the same thing as your full distribution.
rm -rf perl5.004_07 gzip -d -c perl5.004_07.tar.gz | tar -xf - cd perl5.004_07 sh ../perl5.004_08.pat patch -p1 -N < ../perl5.004_08.pat cd .. gdiff -r perl5.004_07 perl5.004_08
where gdiff is GNU diff. Other diff's may also do recursive checking.
Again, it's obvious, but you should test your new version as widely as you can. You can be sure you'll hear about it quickly if your version doesn't work on both ANSI and pre-ANSI compilers, and on common systems such as SunOS 4.1.[34], Solaris, and Linux.
If your changes include conditional code, try to test the different branches as thoroughly as you can. For example, if your system supports dynamic loading, you can also test static loading with
sh Configure -Uusedl
You can also hand-tweak your config.h to try out different #ifdef branches. :-)
It's often the case that you'll need to choose whether to do something the BSD-ish way or the POSIX-ish way. It's usually not a big problem when the two systems use different names for similar functions, such as memcmp() and bcmp(). The perl.h header file handles these by appropriate #defines, selecting the POSIX mem*() functions if available, but falling back on the b*() functions, if need be.
More serious is the case where some brilliant person decided to use the same function name but give it a different meaning or calling sequence :-). getpgrp() and setpgrp() come to mind. These are a real problem on systems that aim for conformance to one standard (e.g. POSIX), but still try to support the other way of doing things (e.g. BSD). My general advice (still not really implemented in the source) is to do something like the following. Suppose there are two alternative versions, fooPOSIX() and fooBSD().
#ifdef HAS_FOOPOSIX /* use fooPOSIX(); */ #else # ifdef HAS_FOOBSD /* try to emulate fooPOSIX() with fooBSD(); perhaps with the following: */ # define fooPOSIX fooBSD # else # /* Uh, oh. We have to supply our own. */ # define fooPOSIX Perl_fooPOSIX # endif #endif
If you need to add an #ifdef test, it is usually easier to follow if you think positively, e.g.
#ifdef HAS_NEATO_FEATURE /* use neato feature */ #else /* use some fallback mechanism */ #endif
rather than the more impenetrable
#ifndef MISSING_NEATO_FEATURE /* Not missing it, so we must have it, so use it */ #else /* Are missing it, so fall back on something else. */ #endif
Of course for this toy example, there's not much difference. But when the #ifdef's start spanning a couple of screen fulls, and the #else's are marked something like
#else /* !MISSING_NEATO_FEATURE */
I find it easy to get lost.
Not all systems have all the neat functions you might want or need, so you might decide to be helpful and provide an emulation. This is sound in theory and very kind of you, but please be careful about what you name the function. Let me use the
pause() function as an illustration.
Perl5.003 has the following in perl.h
#ifndef HAS_PAUSE #define pause() sleep((32767<<16)+32767) #endif
Configure sets HAS_PAUSE if the system has the pause() function, so this #define only kicks in if the pause() function is missing. Nice idea, right?
Unfortunately, some systems apparently have a prototype for pause() in unistd.h, but don't actually have the function in the library. (Or maybe they do have it in a library we're not using.)
Thus, the compiler sees something like
extern int pause(void); /* . . . */ #define pause() sleep((32767<<16)+32767)
and dies with an error message. (Some compilers don't mind this; others apparently do.)
To work around this, 5.003_03 and later have the following in perl.h:
/* Some unistd.h's give a prototype for pause() even though HAS_PAUSE ends up undefined. This causes the #define below to be rejected by the compiler. Sigh. */ #ifdef HAS_PAUSE # define Pause pause #else # define Pause() sleep((32767<<16)+32767) #endif
This works.
The curious reader may wonder why I didn't do the following in util.c instead:
#ifndef HAS_PAUSE void pause() { sleep((32767<<16)+32767); } #endif
That is, since the function is missing, just provide it. Then things would probably be been alright, it would seem.
Well, almost. It could be made to work. The problem arises from the conflicting needs of dynamic loading and namespace protection.
For dynamic loading to work on AIX (and VMS) we need to provide a list of symbols to be exported. This is done by the script perl_exp.SH, which reads global.sym and interp.sym. Thus, the
pause symbol would have to be added to global.sym So far, so good.
On the other hand, one of the goals of Perl5 is to make it easy to either extend or embed perl and link it with other libraries. This means we have to be careful to keep the visible namespace "clean". That is, we don't want perl's global variables to conflict with those in the other application library. Although this work is still in progress, the way it is currently done is via the embed.h file. This file is built from the global.sym and interp.sym files, since those files already list the globally visible symbols. If we had added
pause to global.sym, then embed.h would contain the line
#define pause Perl_pause
and calls to
pause in the perl sources would now point to
Perl_pause. Now, when ld is run to build the perl executable, it will go looking for
perl_pause, which probably won't exist in any of the standard libraries. Thus the build of perl will fail.
Those systems where function that gets called something akin to
#ifndef HAS_CHSIZE I32 chsize(fd, length) /* . . . */ #endif
When 5.003 added
#define chsize Perl_chsize
to embed.h, the compile started failing on SCO systems.
The "fix" is to give the function a different name. The one implemented in 5.003_05 isn't optimal, but here's what was done:
#ifdef HAS_CHSIZE # ifdef my_chsize /* Probably #defined to Perl_my_chsize in embed.h */ # undef my_chsize # endif # define my_chsize chsize #endif
My explanatory comment in patch 5.003_05 said:
Undef and then re-define my_chsize from Perl_my_chsize to just plain chsize if this system HAS_CHSIZE. This probably only applies to SCO. This shows the perils of having internal functions with the same name as external library functions :-).
Now, we can safely put
my_chsize in global.sym, export it, and hide it with embed.h.
To be consistent with what I did for
pause, I probably should have called the new function
Chsize, rather than
my_chsize. However, the perl sources are quite inconsistent on this (Consider New, Mymalloc, and Myremalloc, to name just a few.)
There is a problem with this fix, however, in that
Perl_chsize was available as a libperl.a library function in 5.003, but it isn't available any more (as of 5.003_07). This means that we've broken binary compatibility. This is not good.
We currently don't have a standard way of handling such missing function names. Right now, I'm effectively thinking aloud about a solution. Some day, I'll try to formally propose a solution.
Part of the problem is that we want to have some functions listed as exported but not have their names mangled by embed.h or possibly conflict with names in standard system headers. We actually already have such a list at the end of perl_exp.SH (though that list is out-of-date):
# extra globals not included above. cat <<END >> perl.exp perl_init_ext perl_init_fold perl_init_i18nl14n perl_alloc perl_construct perl_destruct perl_free perl_parse perl_run perl_get_sv perl_get_av perl_get_hv perl_get_cv perl_call_argv perl_call_pv perl_call_method perl_call_sv perl_requirepv safecalloc safemalloc saferealloc safefree
This still needs much thought, but I'm inclined to think that one possible solution is to prefix all such functions with
perl_ in the source and list them along with the other
perl_* functions in perl_exp.SH.
Thus, for
chsize, we'd do something like the following:
/* in perl.h */ #ifdef HAS_CHSIZE # define perl_chsize chsize #endif
then in some file (e.g. util.c or doio.c) do
#ifndef HAS_CHSIZE I32 perl_chsize(fd, length) /* implement the function here . . . */ #endif
Alternatively, we could just always use
chsize everywhere and move
chsize from global.sym to the end of perl_exp.SH. That would probably be fine as long as our
chsize function agreed with all the
chsize function prototypes in the various systems we'll be using. As long as the prototypes in actual use don't vary that much, this is probably a good alternative. (As a counter-example, note how Configure and perl have to go through hoops to find and use get Malloc_t and Free_t for
malloc and
free.)
At the moment, this latter option is what I tend to prefer.
Sorry, showing my age:-). Still, all the world is not BSD 4.[34], SVR4, or POSIX. Be aware that SVR3-derived systems are still quite common (do you have any idea how many systems run SCO?) If you don't have a bunch of v7 manuals handy, the metaconfig units (by default installed in /usr/local/lib/dist/U) are a good resource to look at for portability.
Why does perl use a metaconfig-generated Configure script instead of an autoconf-generated configure script?
Metaconfig and autoconf are two tools with very similar purposes. Metaconfig is actually the older of the two, and was originally written by Larry Wall, while autoconf is probably now used in a wider variety of packages. The autoconf info file discusses the history of autoconf and how it came to be. The curious reader is referred there for further information.
Overall, both tools are quite good, I think, and the choice of which one to use could be argued either way. In March, 1994, when I was just starting to work on Configure support for Perl5, I considered both autoconf and metaconfig, and eventually decided to use metaconfig for the following reasons:, a SVR3.2/386 derivative that also had some POSIX support. Metaconfig-generated Configure scripts worked fine for me on that system. On the other hand, autoconf-generated scripts usually didn't. (They did come quite close, though, in some cases.) At the time, I actually fetched a large number of GNU packages and checked. Not a single one configured and compiled correctly out-of-the-box with the system's cc compiler.
With both autoconf and metaconfig, if the script works, everything is fine. However, one of my main problems with autoconf-generated scripts was that if it guessed wrong about something, it could be very hard to go back and fix it. For example, autoconf always insisted on passing the -Xp flag to cc (to turn on POSIX behavior), even when that wasn't what I wanted or needed for that package. There was no way short of editing the configure script to turn this off. You couldn't just edit the resulting Makefile at the end because the -Xp flag influenced a number of other configure tests.
Metaconfig's Configure scripts, on the other hand, can be interactive. Thus if Configure is guessing things incorrectly, you can go back and fix them. This isn't as important now as it was when we were actively developing Configure support for new features such as dynamic loading, but it's still useful occasionally.
At the time, autoconf-generated scripts were covered under the GNU Public License, and hence weren't suitable for inclusion with Perl, which has a different licensing policy. (Autoconf's licensing has since changed.)
Metaconfig builds up Configure from a collection of discrete pieces called "units". You can override the standard behavior by supplying your own unit. With autoconf, you have to patch the standard files instead. I find the metaconfig "unit" method easier to work with. Others may find metaconfig's units clumsy to work with..
Mainly because no one's gotten around to making one. Note that "making one" involves changing perl.c, Configure, config_h.SH (and associated files, see above), and documenting it all in the INSTALL file.
Apparently, most folks who want to override one of the standard library files simply do it by overwriting the standard library files.
In the perl.c sources, you'll find an undocumented APPLLIB_EXP variable, sort of like PRIVLIB_EXP and ARCHLIB_EXP (which are documented in config_h.SH). Here's what APPLLIB_EXP is for, from a mail message from Larry:
The main intent of APPLLIB_EXP is for folks who want to send out a version of Perl embedded in their product. They would set the symbol to be the name of the library containing the files needed to run or to support their particular application. This works at the "override" level to make sure they get their own versions of any library code that they absolutely must have configuration control over. As such, I don't see any conflict with a sysadmin using it for a override-ish sort of thing, when installing a generic Perl. It should probably have been named something to do with overriding though. Since it's undocumented we could still change it... :-)
Given that it's already there, you can use it to override distribution modules. If you do
sh Configure -Dccflags='-DAPPLLIB_EXP=/my/override'
then perl.c will put /my/override ahead of ARCHLIB and PRIVLIB.
Why isn't the shared libperl.so installed in /usr/lib/ along with "all the other" shared libraries? Instead, it is installed in $archlib, which is typically something like
/usr/local/lib/perl5/archname/5.00404
and is architecture- and version-specific.
The basic reason why a shared libperl.so gets put in $archlib is so that you can have more than one version of perl on the system at the same time, and have each refer to its own libperl.so.
Three examples might help. All of these work now; none would work if you put libperl.so in /usr/lib.
Anyway, all this leads to quite obscure failures that are sure to drive casual users crazy. Even experienced users will get confused :-). Upon reflection, I'd say leave libperl.so in $archlib.
You can upload your work to CPAN if you have a CPAN id. Check out for information on _PAUSE_, the Perl Author's Upload Server.
I typically upload both the patch file, e.g. perl5.004_08.pat.gz and the full tar file, e.g. perl5.004_08.tar.gz.
If you want your patch to appear in the src/5.0/unsupported directory on CPAN, send e-mail to the CPAN master librarian. (Check out ).
You should definitely announce your patch on the perl5-porters list. You should also consider announcing your patch on comp.lang.perl.announce, though you should make it quite clear that a subversion is not a production release, and be prepared to deal with people who will not read your disclaimer.
Here, in no particular order, are some Configure and build-related items that merit consideration. This list isn't exhaustive, it's just what I came up with off the top of my head..
We should be able to emulate configure --srcdir. Tom Tromey tromey@creche.cygnus.com has submitted some patches to the dist-users mailing list along these lines. They have been folded back into the main distribution, but various parts of the perl Configure/build/install process still assume src='.'.).
Various hint files work around Configure problems. We ought to fix Configure so that most of them aren't needed.
Some of the hint file information (particularly dynamic loading stuff) ought to be fed back into the main metaconfig distribution..
On some systems, it may be safe to call the system malloc directly without going through the util.c safe* layers. (Such systems would accept free(0), for example.) This might be a time-saver for systems that already have a good malloc. (Recent Linux libc's apparently have a nice malloc that is well-tuned for the system.)
Get some of the Macintosh stuff folded back into the main distribution.
Maybe include a replacement function that doesn't lose data in rare cases of coercion between string and numerical values.
The current makedepend process is clunky and annoyingly slow, but it works for most folks. Alas, it assumes that there is a filename $firstmakefile that the make command will try to use before it uses Makefile. Such may not be the case for all make commands, particularly those on non-Unix systems.
Probably some variant of the BSD .depend file will be useful. We ought to check how other packages do this, if they do it at all. We could probably pre-generate the dependencies (with the exception of malloc.o, which could probably be determined at Makefile.SH extraction time.
GNU software generally has standardized Makefile targets. Unless we have good reason to do otherwise, I see no reason not to support them.
Somehow, straighten out, document, and implement $ | http://search.cpan.org/~lbrocard/perl5.005_04/Porting/pumpkin.pod | CC-MAIN-2017-43 | refinedweb | 4,663 | 67.25 |
The Aesthetics Layer
00:00 In the previous lesson, you created the data layer, but all you got was a gray square. In this lesson, you will apply aesthetics to this data layer and put them together to end up with a graph that’s already more meaningful than the previous one.
00:16 So, head back over to your Jupyter Notebook and create a new cell. I will convert this again to Markdown and just
00:26
leave a note on what we’re doing,
Aesthetics.
00:30
And you will need an additional function for displaying the aesthetics, so I will import this.
from plotnine import aes (aesthetics), this is what this function is called.
00:44
And just to make sure that you remember, also
ggplot() was the one that you imported before that you need to assign the data. And with this, you already have everything you need.
00:55
You can say
ggplot(), passing in the
mpg dataset. So here, you’re passing in the
mpg dataset and creating the data layer, and then you’re adding aesthetics to it.
01:08
Now the mappings, let’s take another look at the
mpg dataset, just to know what are the columns that you want to map. Now, you want to map
class to the x-axis, so you can say
x="class".
01:24 And it’s enough to just give the names of the columns in the DataFrame that you passed into the data layer.
01:31
And
y is going to be the efficiency on the highway, so how many miles it can drive per liter. And with these two inputs, you’re done. You can execute this, and you get a graph that’s already much more meaningful than the previous one.
01:47 So, in here, you can see that the highway column was mapped to the y-axis, and the class column was mapped to the x-axis.
01:57 There’s also a couple of other things that happened behind the scenes. So, plotnine applied a coordinate system for you, just by default. This is the Cartesian coordinate system.
02:09 And it also applied some scales that it just inferred by looking at the data that you’re passing in. So, these are defaults that are usually quite good.
02:17 You don’t have to change them yourself. But just know that these are additional layers that you can also adapt if you want to. Now, while this looks much better and you applied two aesthetics successfully, you still don’t see anything because there’s no geometric objects defined, so plotnine doesn’t know how to plot the data points for you.
02:37 You will learn how to do that in the next lesson.
Become a Member to join the conversation. | https://realpython.com/lessons/aesthetics/ | CC-MAIN-2021-39 | refinedweb | 476 | 80.21 |
#include <Arrays.h>
List of all members.
Definition at line 307 of file Arrays.h.
A lot of things is shared by these three arrays. That is why there are more base classes: {itemize} {ArrayBase} defines functions independent of the elements type {ArrayBaseT} template class defining functions shared by {DArray} and {TArray} {itemize}
The main difference between {GArray} (now obsolete) and these ones is the copy-on-demand strategy, which allows you to copy array objects without copying the real data. It's the same thing, which has been implemented in {GString} long ago: as long as you don't try to modify the underlying data, it may be shared between several copies of array objects. As soon as you attempt to make any changes, a private copy is created automatically and transparently for you - the procedure, that we call "copy-on-demand".
Also, please note that now there is no separate class, which does fast sorting. Both {TArray} (dynamic array for trivial types) and {DArray} (dynamic array for arbitrary types) can sort their elements.
{ Historical comments} --- Leon chose to implement his own arrays because the STL classes were not universally available and the compilers were rarely able to deal with such a template galore. Later it became clear that there is no really good reason why arrays should be derived from containers. It was also suggested to create separate arrays implementation for simple classes and do the copy-on-demand strategy, which would allow to assign array objects without immediate copying of their elements.
At this point {DArray} and {TArray} should only be used when it is critical to have the copy-on-demand feature. The {GArray} implementation is a lot more efficient.
Template array classes. | http://djvulibre.sourcearchive.com/documentation/3.5.23/classArrayBase.html | CC-MAIN-2018-13 | refinedweb | 287 | 51.58 |
Storage Volume Provider
The Storage Volume provider supplies volume management functions. The provider enumerates all existing volumes that the Windows Mount Manager recognizes, and volumes enumerated in the FindFirstVolume or FindNextVolume Windows APIs.
You can use this provider to manage volume drive letters, mount points, and for storage quotas. The Storage Volume provider also has methods to defragment, check, mount, dismount, and format a volume. This provider does not manage mapped network or diskette drives. No direct relationship exists between Win32_Volume and Win32_DiskDrive. The name of the __Win32Provider instance name is "MSVDS_PROVIDER".
Windows XP: The Storage Volume Provider is not available.
The Storage Volume provider can modify and enumerate disk volume objects. This provider is implemented through the instance of __Win32Provider named "MSVDS_PROVIDER". PutInstance is supported for classes that belong to this provider.
The Storage Volume provider is an instance and method provider that implements the standard IWbemProviderInit interface, and the following IWbemServices methods:
The Storage Volume provider supports the following classes:
The Storage Volume provider supports the following association classes in the root\cimv2 namespace:
The Win32_Volume class defines the following methods to manage volumes: | https://msdn.microsoft.com/en-us/library/aa393675(v=vs.85).aspx | CC-MAIN-2017-22 | refinedweb | 186 | 55.84 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.