#include<stdio.h>

for(i=0;i<length;i++)
{
for(j=i+1;j<length;j++)
{
if(arr[i]>arr[j])
{
t = arr[i];
arr[i]=arr[j];
arr[j]=t;
}
}
}
}

tip to the alive controller using serial port or telnet to it using port 2463
Send <BREAK> for Service Interface or baud rate change ( ctrl ] )
telnet> send brk
Press within 5 seconds: <S> for Service Interface, <BREAK> for baud rate
==> Here you must press esc key instead of “S” to get the service menu
Current date: 12/17/06 time: 08:54:51
Enter password to access shell: y2llojp
LSI Logic RAID Controller
Copyright 2004-2006 LSI Logic Corporation. All Rights Reserved.
Copyright Wind River Systems, Inc., 1984-2003
VxWorks: VxWorks5.5.1 Kernel: WIND version 2.6
Model: 3994 Firmware version: 06.19.18.10

-> isp rdacMgrAltCtlResetRelease

==> If the login request username and password:

VxWorks login:
Password:

==> Then use:

root / y2llojp

User 2
for baud rate
<==== Please press “esc” instead “S” and it will go to the below.
VxWorks login: shellUsr
Password: y2llojp
-> isp rdacMgrAltCtlResetRelease

Well it turns out that all but three of us had other plans tonight, so we decided to postpone Meeting #3 until next week. We’re working through chapters on our own in the meantime, so tonight I sat down with Chapter 5.

If you recall, Chapter 4 had us split a list of Surf-A-Thon results into names and scores, then sort the scores and print the top three. But we need to know who those scores belong to, so we need a way to associate the names with the scores.  I’ve been thinking about this.

If you also recall, I’ve recently read a chapter on PHP arrays, and thus have just enough knowledge to be dangerous (or plain stupid). According to that chapter, PHP allows you to store a whole other array (array’, if you will) inside an array element. [This makes me think of a universe within a universe, or, in other words: "Phenomenal cosmic power... itty-bitty living space."]  In any case, it seems to me that one way to solve our name-score problem is to create an array whose elements are scores, and then to create a one-element array’ for each of those, whose one element would be the associated name.

Actually, if Python allows strings as keys, perhaps we could just make each name the key and each score the value?  One possible catch comes to mind here: In the array with numerical keys, the values became “detached” from these keys when they were sorted.  If the same phenomenon occurs with strings as keys, that won’t work.

Here’s another way to say it: Think about each element in the array as a train car, with the keys painted on the side and the values stored within.  When the keys were numerical (0, 1, 2, etc.) and we sorted the contents, the train cars stayed hitched in the same order, and the contents were removed, reshuffled, and reinserted.  Then we were able to print the contents of cars 0, 1, 2 and we received the three highest scores.  So I wonder: if we paint strings on the sides of the cars, names in this case…

1. will the cars get unhitched—with their contents still inside—and reshuffled?
2. will the cars stay where they are while the contents are removed, reshuffled, and reinserted (as before)?
3. or, perhaps, will the contents be removed, reshuffled, and reinserted while someone scrubs off the paint and repaints the cars so that the strings are also sorted (in some kind of order—alphabetical?)?

It’s difficult for me to think of more than one or two scenarios in which option 3 would be useful, so I hope that’s not the way it was designed.

Chapter 5 begins by asking us to be like the fox, who makes more tracks than necessary, some in the wrong direction: it suggests that we create two arrays (one for names and one for scores).  Well it takes me all of two seconds to recognize that this is a thoroughly useless approach; the minute we cleave this data and shuffle it, we’re done for. It’s like cutting a stack of papers at the margins containing the page numbers, and then dropping the resulting stacks on the floor.

So, okay, flipping ahead… I’m told there’s this thing called a hash.  Well, actually, the Pythonic term is a dictionary.  (Python peeps, enough of this alternative vocabulary.  What are you, special?  So some of you have a pony.  Good for you.*)  Well, actually, I’m told there’s a hash, and a set (no problems), and a queue (no problems), and a linked list, and a multi-dimensional array.  Perhaps this last is the equivalent of the PHP genie?  But no matter, the hash has exactly two columns, so it appears to be what I really need.

At this point, potential dinner plans appear and I decide to seize the moment, so tune in later to see how all this works out…

*Nuthin’ but love, peeps.  Nuthin’ but love.  :-)

Let’s start with a quote from ‘Learning Perl‘:

What Is a Hash?

A hash is a data structure, not unlike an array in that it can hold any number of values and retrieve them at will. But instead of indexing the values by number, as we did with arrays, we’ll look up the values by name. That is, the indices (here, we’ll call them keys ) aren’t numbers, but instead they are arbitrary unique strings

Our goal: We want to store an array as a value in the hash instead of saving a single value.

Let’s write some code:

#!/usr/bin/perl
use strict;
use warnings;

my %hash = ();
my @array = (1, 2, 3, 4, 5);
my $aref = \@array;
$hash{"Testing"} = $aref;
push(@{$hash{"Testing"}},6);
print join " ",@{$hash{"Testing"}};

This piece of Perl code stores an array as a value in a hash and adds a new element to the array.

Now let’s analyze the code.

First we create an empty hash and we create an array and initialize it.

my %hash = ();
my @array = (1, 2, 3, 4, 5);

Now we need a reference of our array (so that we can store it as a value in the hash):

my $aref = \@array;

In the next step below we actually do what we wanted. Storing an array into a hash value. We create a key in our hash called "Testing" and store the reference of our array in the value field.

$hash{"Testing"} = $aref;

We can see that the reference of our array ($aref) is pointing to our array so we can access the array in our hash.

This code adds a new element with value '6' to our array:
push(@{$hash{"Testing"}},6);


Explanation: 
# Gives the value of key Testing, it's the reference to the array
$hash{"Testing"}

# Dereference it with {} to access the array (that's why we have an @ at the begin)
@{$hash{"Testing"}}

I hope that helped  

Hey, thanks so much for all the great discussion and engagement.  It’s a huge encouragement to have experienced Pythonistas (and fellow n00bs!) join in the conversation.

Just a quick update on what I’ve been doing this weekend as I finish up Chapter 3 (which I started Monday night) and move through Chapter 4.

I mentioned in my last post that Chapter 3 continues to look at the coffee bean pricing example, and that it has us interacting with the Twitter API.  That piece of code was given to us as:

def send_to_twitter(msg):
    password_manager = urllib.request.HTTPPasswordMgr()
    password_manager.add_password(“Twitter API”,         ”http://twitter.com/statuses”, username, password)
    http_handler =         urllib.request.HTTPBasicAuthHandler(password_manager)
    page_opener = urllib.request.build_opener(http_handler)
    urllib.request.install_opener(page_opener)
    params = urllib.parse.urlencode( {’status’: msg} )
    resp = urllib.request.urlopen(“http://twitter.com/statuses/
        update.json”, params)
    resp.read()

I guess I basically understand what this does, but it wasn’t presented in detail.  One question it raised for me concerns the functions in the urllib.request library (or module, as I’m told is a Pythonic synonym).  You may remember an earlier post in which I consulted a Pythonista friend of mine who suggested the use of:

from urllib.request import urlopen

Well, looking at the send_to_twitter() function, I of course notice that we’re calling half a dozen different functions from the same module.  Surely it’s easier to import the whole module (in one line of code) than to import the functions individually (in six lines of code), yeah?  Where would the line be drawn on this Pythonic technique?  It’s okay to import two functions individually?  Three?  Opinions, please.

All that aside, we did learn to define our own functions (and to use these to avoid code duplication) as well as how to pass parameters to functions.  We also covered stack frames and local variables.  So far, so good.

Chapter 4 covers files and arrays.  Hooray!  To explore data structures, we left behind coffee beans for a more recreational example: Codeville’s annual “Surf-A-Thon”.  First we learned to read a text file stored on disk, and to do so line-by-line using a for loop.  Each line contained a name and a score, so we used split() to divide the strings and learned to create an array with names and scores.  Finally, we learned to use sort() and reverse() so that we could print the top three scores.  Chapter 5 will apparently show us how to retrieve and display the corresponding names.

Coincidentally, I’m currently editing a book on PHP and happened to read the chapter on arrays earlier this week.  So as I was working through Chapter 4 I had fresh in my mind certain details from the PHP chapter, and these structures seem to work in similar ways with Python.  One thing I wonder about: PHP distinguishes between indexed arrays (with numerical keys) and associative arrays (which allow strings as keys).  With the Surf-A-Thon example, we didn’t specify our keys but let Python auto-populate them for us by using append(), and Python chose numerical keys beginning with 0 (which PHP would do as well).  But I wonder whether Python also allows strings as keys, and whether it distinguishes arrays by key type.  I could go look it up (and might soon), but conversation is much more fun, so feel free to jump in on that.  :-)

Our group’s next meeting is tomorrow night (Monday again), and hopefully the rest of the group has also gotten through Chapter 4 so we can all start Chapter 5 together.  More updates soon!

Due to another conference (can’t they distribute them a bit more evenly around the year?) I won’t be here for the next three exercises.

In today’s Programming Praxis we’re going to implement a growable array, which is a data structure with logarithmic access where elements can be added without needing reallocation. Basically it’s little more than a binary tree. Let’s get started.

We’ll use a fairly standard binary tree for our data structure:

data Grow a = Empty | Grow { val :: a, l :: Grow a, r:: Grow a }

Next, we want a function that handles taking the correct branches, since we don’t want to have to repeat ourselves.

walk :: (Int -> Grow a -> b) -> Int -> Grow a -> b
walk f i = f (div i 2) . if even i then l else r

We also define another convenience function that handles updating the tree. Unfortunately Haskell doesn’t have first class records yet, so there is some duplication of logic here.

modify :: Grow a -> (Int -> Grow a -> Grow a) -> Int -> Grow a -> Grow a
modify d _ _ Empty         = d
modify _ f i g | even i    = g { l = walk f i g }
               | otherwise = g { r = walk f i g }

Now for the three functions we had to implement: get, put and hirem. Thanks to walk and modify, these are all fairly trivial.

get :: Int -> Grow a -> Maybe a
get _ Empty = Nothing
get 1 g     = Just $ val g
get i g     = walk get i g

put :: Int -> a -> Grow a -> Grow a
put 1 x Empty = Grow x Empty Empty
put 1 x g     = g { val = x }
put i x g     = modify (error "array out of bounds") (`put` x) i g

hirem :: Int -> Grow a -> Grow a
hirem 1 = const Empty
hirem i = modify Empty hirem i

And of course we have to test if we made any mistakes:

main :: IO ()
main = do let arr = foldl (flip (uncurry put)) Empty $ zip [1..]
                    ["alfa", "bravo", "charlie", "delta",
                     "echo", "foxtrot", "golf"]
          print $ get 7 arr
          print $ get 12 arr
          print . get 7 $ hirem (size arr) arr
       where size Empty = 0
             size g     = 1 + size (l g) + size (r g)

Looks like everything is working correctly. See you guys in two weeks!

Let’s say you have 2 arrays and you would like merge the two into one array.

Here is a simple ColdFusion function I have put together to do just that.

<cffunction name=”arrayMerge” access=”public” returntype=”array” output=”false”>
<cfargument name=”array1″ required=”true” type=”array”>
<cfargument name=”array2″ required=”true” type=”array”>

<cfset var a1 = arguments.array1>
<cfset a1.addAll(arguments.array2)>

<cfreturn a1 />
</cffunction>

#include <vector>
int arr[4];
vector<int> ivec(arr, arr + 4);

So lets create a new.cpp file and call it var.cpp. Today’s lesson is about variables. A variable is simply a container that holds something like a number, string, etc. A variable can be called anything except asm, auto, bool, break, case, catch, char, class, const, const_cast, continue, default, delete, do, double, dynamic_cast, else, enum, explicit, export, extern, false, float, for, friend, goto, if, inline, int, long, mutable, namespace, new, operator, private, protected, public, register, reinterpret_cast, return, short, signed, sizeof, static, static_cast, struct, switch, template, this, throw, true, try, typedef, typeid, typename, union, unsigned, using, virtual, void, volatile, wchar_t, while. So lets begin with a simple addition example:
#include <iostream>
using namespace std;

int main()
{
int a,b;
a=5
b=9
cout<< a+b;
system("pause");
return 0;
}

After you compile this code you should getthe number 14 in your command prompt. “a=5″ means a contains the number 5 so if you had typed cout<<a; it would print the number 5. The same is for b it contains the number 9. So when we put a + b it was the same as asking 5 + 9. Simple? Incase you dont understand think of a variable as a box which holds what you tell it. So we told a to hold 5. Now when we use the a box it contains 5. That should be pretty simple. Lets move on to showing how to use strings (lines of letters and words) with variables…

#include <iostream>
using namespace std;



int main()
{
string war;
int x;
war="I like to use variables!!!"
x=2009
cout<< war << "It all started in" <<
system("pause");
return 0;
}

In this example we use the word “war” as the variable with holds the string “I like to use variables!!!” an x hold the number 2009. So all you need to really know about variables is that they contain what you what. Next lesson will be a little more on variables and how to change them to a new value.

Working extensively with Strings inevitably entails working with arrays. Lots of them. In this article I will be looking at how some of the pain can be taking out of this in our putative replacement class for String.

First off, one thing which makes working with String arrays easier is to convert your array to a Vector, ArrayList or one of the other Collection classes; your mileage will vary based around a number of criteria, not the least being what you intend to do, whether you need to handle this in a threaded manner, etc, etc and due consideration of the right Collection class to utilise is important; I have opted for Vector for this illustration because it has broadly based utility.

Arrays inherently are messy to work with and serial abuse of them inevitably results in an unhealthy proliferation of for loops, often nested to the point of Lovecraftian insanity.

Let’s therefore pretend for the purposes of simplicity & clarity in this article that we only have the Vector class with which to work. First off we’ll need to add

import java.util.Vector;

to our class header.

On demand empty String Vector

Next we’ll need a method to create an instant on-demand String Vector method:

public  Vector<String> getPreparedVector()
{
Vector<String> vOutput = new Vector<String>();
return vOutput;
}

Converting String[] to a Vector

Next up we need to have a method to pass a String array to a Vector since most of the inbuilt String class methods we frequently need recourse to produce output as an array. This we can do as follows:

/*
* @param inArray - the array to convert to a Vector
* @return the populated Vector from incoming String array
*/
public  Vector getVectorFromStringArray(String[] inArray)
{
// since this will be the same length as s but parsed
Vector<String> v = getPreparedVector();
for (int i = 0; i < inArray.length; i++)
{
v.add(inArray[i]);
}
return v;
}

Vector to String[]

And of course we will likely need a method to reverse the process, i.e. to convert the Vector back to an array…

/**
* Will convert a passed vector to a string array
* @param Vector v - the vector for conversion
* @return String array of the converted vector
*/
public String[] vectorToStringArray( Vector v )
{
int count = v.size();
String[] outArray = new String[count];
v.copyInto(outArray);
return outArray;
}

Vector is responsible for very little of the code in the above method, and you are probably seeing already why it is a better candidate for hardcore work than an array: it has functionality which obviates the need for intricate loops. Most of the effort here derives from having to accomodate the somewhat Byzantine complexities of the Array class.

Growing a vector

One immediate advantage which a Vector has over an array is that the number of elements which it contains can be increased or decreased dynamically. The API documentation for Vector makes this point explicitly:

The Vector class implements a growable array of objects. Like an array, it contains components that can be accessed using an integer index. However, the size of a Vector can grow or shrink as needed to accommodate adding and removing items after the Vector has been created.

Each vector tries to optimize storage management by maintaining a capacity and a capacityIncrement. The capacity is always at least as large as the vector size; it is usually larger because as components are added to the vector, the vector’s storage increases in chunks the size of capacityIncrement. An application can increase the capacity of a vector before inserting a large number of components; this reduces the amount of incremental reallocation.

Inevitably, we will want to add and remove elements from our Vector; a royal pain with an Array, but a moment’s work in a Vector…

Vector<String> v = getPreparedVector();
v.add("Hello");
v.add("World");
v.add("A superfluous element");
v.add("etc");
v.remove(3);

[..]

Interesting Things about Classes

• Starting class names with an uppercase letter is actually enforced. I think that this is a good thing, though that is a very easy typo to make.
• Members aren’t necessarily declared.
• A “class method” is sort of like a static method in Java, in that it can be called from anything, not just on an instance. Prepend names of class methods with “self.” to indicate that it is a class method, otherwise it is an instance method.

Control Structures are Confusing!

The example given on page 671 is very confusing. The structure basically looks like this:

objects.each {|o| something with o}

Okay, so upon further examination, this isn’t that complicated. It’s sort of like the each operator (?) in jQuery. We call .each on the object which is a collection of some objects. The bit in the curly braces is what is performed on each of them, with the bit between the lines being the variable that is assigned to each item in the array. Okay, I think I’m good with that bit now.

Back to Classes…

No, I don’t want to go back to school! (Though this seems like a pretty cool course.) Anyway…

• Constructor methods seem to be called “initialize”, at least in this example.
• All instance variables are essentially private. To fix this, either write getters and setters. Or you can do something awesome! Declare your instance variables like this to get getters and setters or just one:

  attr_accessor   ne     # I can be read and written to!
  attr_reader    :two     # I can just be read
  attr_writer    :three   # I can just be written to  

• Getters are easy to write, but using attr_reader is even easier. (note that ~ means a space)
  def my_var
~~@my_var
end
• If you do for some crazy reason want to write setters, you can do it like this:
  def my_var=(new_val)
~~@my_var = new_val
end
• Private and protected access levels are a bit different than in other languages. Private methods can only be called from within the same instance. So a comparator method couldn’t use the private methods of the other object in question. Protected is what you would expect though. These directives are easy to use, just declare them on a the line between the previous end statement and the method you’re interested in’s def statement, with a whitespace line between each of those (?).

Modules are sort of like classes in that they are a collection of methods and other sorts of definitions, but you can’t make objects of them, so they’re more like entirely static classes, i.e. helper classes.

Nil means nothing. Well, it doesn’t quite mean nothing or I wouldn’t be mentioning it! But it represents nothing. I think that’s a more accurate description. It evaluates to false in a conditional expression. This is returned when a hash index doesn’t actually correspond to a key in the hash.

Arrays! Il faut savoir qu’ils n’ont pas nécessairement de genre, donc chaque pièce pourrait avoir un genre différent. You define a variable as an array using square brackets, like below.

a = [ 'first', 'second', 3 ]

You don’t have to initialize it with any values. You can use the << operator to add elements to the array (push them back, if you will). Indices start at zero, like all other sane languages do.

Hashes are associative arrays, which are very useful. You can use essentially any object as a key, though using a string seems the most sensible to me. They’re declared with curly braces instead of square brackets. See below for an example with some of my past profs. Pretend there is indentation. WordPress doesn’t like writing code in it.

profs = {
:intro = 'Chris Ingram',
:logic = 'Richard Trefler',
:assembly = 'Ondrej Lhotak',
:softeng = 'Michael Godfrey',
:data_structures = 'Gordon Cormack'
}

Assuming that I was forgetful about who my profs were for particular courses (which I’m not since I just wrote that list from memory), I could write profs[:intro] to figure out who my CS 134 prof was back in the day.

Control Structures

• elsif is used instead of else if
• end terminates a conditional block or a while loop
• and can be used instead of &&
• Like Perl, you can do an if statement at the end of a line if it just applies to that single line. The unless statement is also pretty cool. With Ruby though (maybe you can with Perl as well – I’m not a Perl expert), you can also do this with while statements. Examples:

puts "Error!" if !ret
puts "Error!" unless ret

Okay, I think I’m done for tonight. I should try to get to bed relatively earlier so my sleep schedule isn’t that messed up when I get back on Eastern time on Saturday! Tomorrow, I will tackle the remainder of Appendix A and hopefully get through Chapter 2 since it is pretty short. If there is time after packing, I will also try to get my development environment set up, thanks to Chapter 3.

… and an alternative.

In this discussion at Eng-Tips I recommended the use of the DMAX() function to extract maximum values from data grouped with different text labels.  In the process I needed to adjust the selection criterion to generate the correct results.  DMAX requires a criteria range of at least two rows and one or more columns.  In the simplest case the criterion consists of a column header with the criterion underneath; for instance:

=DMAX(datarange, 2, criteria)

Where criteria is a two row range containing:

First Name
Fred

Will return the maximum value from Column 2 from any row with the text “Fred” in the column headed “First Name”.

Unfortunatly this will not always work as expected, and in the example in the Eng-Tips discussion a criterion of M1 was also returning values from rows with labels M11, M12 etc.

The correct way to specify the criterion is to enter:

=”=M1″

which will appear as:

=M1

An alternative is to replace the DMAX function with an array function that will do the same job:

=MAX(IF(EXACT($C$7:$C$12928,U7),$E$7:$E$12928,-1000000))

In this case the labels are in Column C, the criteria are in Column U, and the data from which the maximum values are required are in column E.  The final negative number must be less than the most negative value in the datarange.

This formula must be entered as an array function (by pressing ctrl-shift-enter).  The screenshot below shows an example.

Array Formula as an alternative to DMax(), click to see full size

1. The criteria occupy only one cell, so may be placed in a list, next to the formula output
2. The criteria consist only of the text, without an equals sign

Eng-Tips members may download an example spreadsheet from the link.

Okay, so maybe I should have started with this first instead of with the OOP fundamentals. Today I spent about 3 hours learning C. I familiarised myself with the concept of pointers and how they are used to explicitly pass variables by reference, how they allow a function to manipulate and alter the parameters that were passed to it without needing to copy them, and the way they generally fit into C in terms of memory management. Structures were new too, which seem handy. The concept of header files and function prototypes is also new to me (coming from a Java background). One thing that struck me though, is how “dangerous” the C language is. It allows you to do all kinds of silly things, like e.g. fetching the 11th entry in an array that is only 10 entries long. “Allows” in the sense that the compiler does not complain (well it wouldn’t), but also that during runtime, no errors get thrown. With this in mind, probably the only thing that the C language “allows” (in the previous context) is for the programmer to be extremely cautious when using arrays, especially when it comes to nested loops and similar slightly more advanced tasks. Not only arrays need heed though, C memory management in general seems a bit like skating on a lake that only froze over yesterday. Predictably, I will be a bit uncomfortable when using arrays in double and triple loops in C; 9 times out of 10 it was the NullPointerException that used to come and brighten up my console when I used to (mis)program in Java. Ironically, it is right now brightening up my post editor as the spell checker nostalgically underlined it with a red dotted line… love it.

Today wasn’t a very productive day in terms of “Luka’s iPhone dev prjct” (the L in the logo stands for Luka in case you were wondering). Someone asked me for some help with advertising their house that they want to sell so that took some time. I also finally got around to fixing my windsurfing sail. I tore a hole in it a few weeks ago when coming out of the water, don’t ask me how because, I don’t know how I did it myself, and the monofilm repair kit that I ordered to fix it only arrived yesterday. That’s all right though because there hasn’t been almost any wind these last two weeks, and the forecast looks amazing for Sunday. The forecast wind is one that hasn’t blown–in terms of windsurfing proportions–all summer, yet it’s the highest forecast of the summer. It means I can go to a special spot that is characterised by very nice Caribbean-style turquoise, shallow water . I’ve never sailed my board there but I’ve sailed past by boat many times, the first time we almost hit the bottom, that’s how shallow it was. Which leads me to think there’s even a possibility of some breaking waves, which should be fun! On top of that, I’ve got a friend coming down, especially for Sunday’s wind, which is a 3 hour ferry for him (each way). It all came together perfectly, I could’t imagine a more majestic synthesis of events.

Pardon that digression, although if you’re a windsurfer I’m sure you can relate. If you aren’t let me just say this: windsurfers are a spiritual lot who deify the wind, to us, the wind is a highly beloved yet fickle and unpredictable god who is not afraid to inflict letdown, he is however equally kind, and on rare occasions he rewards our loyalty and perseverance with exceptional sailing conditions that then become the talk for many months to come-until that next epic day. Sunday promises to become one of those days.

Now, back on topic! I did not learn from “The C Programming Language” book as I said I would. I found a tutorial online that upon first inspection seemed to be even more concise than the book, and free, and was updated very recently, it contained specific instructions for a modern IDE, which so happened to be Xcode, which is what I will be using for developing on the Iphone… So I chose to study from there. I haven’t finished it but so far I can only recommend it. Looking to learn C on a Mac? Have a look on www.masters-of-the-void.com.

Damn, that post took about an hour and a half to write, and it contained almost no relevant information. Woops.

Luka

I decided to model the Maine School of Law, because my son started there this year. The law school is housed in one of those ultra modern, 70s style concrete tower kind of building. It’s made up of a series of concrete columns arranged in a circle with glass windows appearing in the spaces between the columns. So finally I was able to construct with the technique of copying arrays (using the rotate tool, while copying with modifier key) I practiced a little and it worked! Also made sure that each concrete column was a Component, not individual objects. That keeps the file size count down enough to be acceptable for Google Earth. It was fun to try and now I know how. I learned the method just by watching the great tutorial videos made by the SketchUp crew, freely available to anyone who wants to learn it.. (link on left for the videos, the array video is in the intermediate group) Here’s a picture of the finished model.

I recently needed to extract data from a series of tables on separate worksheets, into a form suitable for plotting on an XY graph.  In Lotus 123 this would be a piece of cake, since the Lotus @INDEX function has an optional third parameter allowing the sheet number to be selected.  Unsurprisingly, I could find nothing on the subject in the Excel help files, but surprisingly I couldn’t find anything on the Internet either.  I ended up using the INDIRECT() function, as shown in the screen shot below (click image to see full size):

Retrieve data from a 3D range using INDIRECT()

I have entered sheet names in column B and the cell address in row 3, then the formula to retrieve the data to go in cell D5 is:
=INDIRECT(“‘”&$B5&”‘!”&D$3)
Note the $ signs that keep the address referring to the correct column and row when it is copied, and the apostrophe between the double quotes at the start and before the exclamation mark.  Also note that the sheet names in column B are now just the name as it appears on the tab, without the !.

Does anyone have an alternative method?
Is there a neat way to fill the sheet name column automatically?

Edited 27 August 09 following comments from Harlan Grove, who also provided some alternative ways of tackling it (see comments below)

Contract Übertragungsrechte an Bundesliga-Spiele, aber die außerhalb der terrestrischen und Satelliten-Internet wird verschlüsselt, und der Türkei. Also, was vergessen? Satelliten-Receiver, indem Sie die folgenden Werte Biss Abschnitt können Sie die Spiele ohne Probleme zu sehen … Biss ID: 0 × 0 × 1FFF oder 1ffe (6-stellig, nur 0 × 0 × 001fff oder 001ffe) [Some-Empfänger können in der 011919. geschrieben werden, um diesen Teil.] Key Value: 1000000000000000 (12-stellig ist 10000000000000) Darüber hinaus diejenigen, die unverschlüsselt zu sehen TRT, dass sie die Frequenz aufgezeichnet: Diese Frequenz 11094. H unverschlüsselt 24444. Wenn Sie nicht folgen wollen, dass die oben genannten, müssen Sie biss Schlüssel eingeben … HINWEIS: Sie müssen GoldMaster DEVICES FOR YOU ENTER FREQUENCY 24444 V 11919. i] 7500 weiter cis-Serie Anbieter: 011919. eckdaten: 0E Schlüssel: 1000000000000000 Weiter 2000 Serial-Taste, um die Bundesliga TRT Biss Biss ID: 0 x 1 f f e Frequenz: 11919. Symbol Rate: 24444. Polarisation: VER KEY: 10 00 00 00 00 00 00 00 Vestel dvb 3600 1FFE-01-10000000000000 Vestel 840 ci dvb 001FFE 00 1000000000000000 Um Dreambox F 00011FFF 00 1000000000000000; TRT 1 F 00011FFF 01 1000000000000000; TRT 1 B 11919:24444: V 1000000000000000; TRT 1 Kaon-Instrumente für 000000 00 1000000000000000 benjamin dsr 8000 10 00 00 00 00 00 00 00 8280 beginnt mit biss-Menü. Goldmaster 76100. ff – 10 00 00 00 00 00 Taplin Serie 1FFF 1000000000000000; TRT 1 Redline für 10 CSX trt 19919. – V – 24444. Biss Key 00 1F FF 2A Index 1000000000000000 Yumatu IQ – für die Serie 2600 000001 11919 1000000000000000 2600 000003 11919 1000000000000000 Für Humax 5400 NBA TV Schlüssel in ihr Passwort trt siliniz.Eski Werte 1ffe als caid 11094. H 24444. Frequenz nach değiştiriniz.Daha oder andere 11919. v Warten Sie 30 Sekunden auf dem 24444.. Amstrad plus 16100. 002600 00 10 00 00 10 00 00 00 00 Goldmaster-Serie für TRT Sendungen über 2-Frequenz gegeben sind. dieser Frequenz (11919 V 24444) löst Publikationen. Für TRT 1 und TRT 3: Biss ID: 0 × 1FFF (wenn auch nur 0 × 6-stellige 001FFF), Preis-Code: 1000000000000000 (wenn Sie 12 Haushalte 10000000000000) -80800CI-4450-56000-Serie 4000-9000 im Modell System-Einstellungen-Menü wählen Sie sich 121 auf den Drop-down-Menü ETID Code Abschnitt über die Kontrolle durch Betätigen des roten Knopfes Biss geben Sie geben das Verschlüsselungssystem und Kontrolle über die in der ersten Zeile, indem Sie die Pfeiltasten, um das Passwort eingeben. (Neueste Software ist auf Ihrem System-Einstellungen Menü-Taste 121 aus dem Dropdown-Menü, wenn Sie auf die Option Set installiert werden schriftlich *** s werden Standard) 70500-74000-76000-76500-76100-74200-50200-50300-50400-50800 im Modell Die Kontrolle über die Menü-Taste, 8282 *** Drop-Down-Menü wählen Sie die Optionen Streit über die Kontrolle drücken Sie die Pfeiltasten links rechts Tasten biss Abschnitt durch und kommen in jeder Zeile durch Drücken der Pfeiltasten, um das Passwort eingeben. 8000 Series-Modelle Die Kontrolle über das Menü, wählen Sie sich 9317 und im Dropdown-Menü steuern *** auf die Menü-Taste im Dropdown-Menü, Verschlüsselungssysteme, kryptographische Systeme Biss wählen Sie aus dem Drop-Down-Menü auf jegliche Kontrolle über die Linie durch Drücken der Pfeiltasten um das Passwort einzugeben. 11200-11300-11400-20200-20300-20400-30300-30400-30700 in Serie Modell April 2006, nachdem Sie die Software installieren, die Kontrolle über das Menü wählen Sie sich 6382 aus dem Pulldown-Menü über die Kontrolle AUX durch Drücken zurückgesetzt *** s, dann die Kontrolle über TV und Radio, indem Sie biss-Verschlüsselung System-Menü, gehen Sie in den Pfeil auf der ersten Linie durch Drücken von Enter your password. 40400-90900-40100-40200-30800-40300-40700-50100 – Serie von Modellen Modelle, die Kontrolle über *** 40400FTA-40400CI-90900CI Spiele Menü-Taste Option in der Liste mit den Pfeiltasten auf der Fernbedienung Drop-Down-Menü auf der linken richtigen Tasten drücken, um das System mit dem BISS-Verschlüsselung eingeben. On-line Kontrolle über rot 1FF9 und drücken Sie die Pfeiltasten auf der *** Option geben Sie das Kennwort. Hinweis: *** Liste keine Option im Spiel, indem Sie die Kontrolle über 9999 aktive emuyu bitte. 40100FTA-40100CI-40100SKY-40200SKY-40300FTA-40300CI-40700FTA Modelle, die Kontrolle über die Menü-Taste drücken Spiele in Ihrem Code bearbeiten auf den Pfeil-Button Dropdown-Menü und ein Passwort einzugeben 0000 und aus dem Menü auf der rechten Seite steuert die Linke mit die Tasten Biss Verschlüsselungssystem zu betreten. On-line Kontrolle über rot 1FF9 und drücken Sie die Pfeiltasten auf die Option 8Byte *** Bitte geben Sie das Kennwort ein. Option im Menü Pfeil auf den Pfeil, indem Sie speichern. Hinweis: Der Code ist nicht aktiv bearbeiten Option im Menü 2486 Menü Passwort, indem Sie die 19370. aktive emuyu bitte. 14200-14300-14400-14700-14900 im Modell Die Kontrolle über die Menü-Taste drücken Sie die Pfeiltasten üzrinde SmartCard Option Option im Dropdown-Menü Pfeil *** Manager. Drop-Down-Menü mit den Pfeiltasten Biss durch Drücken der Pfeil auf der Drop-down-Menü-Option 000ff9 drücken Sie die Pfeiltasten auf der Drop-down-Menü-Optionen auf dem CW drücken Sie die Pfeiltasten und das Passwort einzugeben. Hinweis: SmartCard-Option ist nicht aktiv Menüpunkt aktiviert Ihre SmartCard unter der Rufnummer 9999999. Models in 70100-70300-70400 Die Kontrolle über die Menü-Taste drücken Sie die Pfeiltasten üzrinde SmartCard Option Option im Dropdown-Menü Pfeil *** Manager. Drop-Down-Menü mit den Pfeiltasten Biss durch Drücken der Pfeil auf der Drop-down-Menü-Option 000ff9 drücken Sie die Pfeiltasten auf der Drop-down-Menü-Optionen auf dem CW drücken Sie die Pfeiltasten und das Passwort einzugeben. Thermische Olimpia Serie Biss Abschnitt 00001FFA: 1000000000000000 dieser Linie girin.Diğer NBA TV 00001FFA:? ????????? das heißt, löschen Sie diese Zeile. Dann TRT 1açılaçaktır.Bu line TRT1 kann nicht sehen Sie nicht löschen. Kyoto 9900DCI-9900D-9910D-9910DCI -9600 ’s für TRT 1 und die folgenden Werte Nummer eingeben, um Ca ID: 26 Provider ID: 1f fa 00 k.e.y Index: 00 k.e.y: 10 00 00 00 00 00 00 00 mit den Pfeiltasten und stellen Sie dann aus. Amstrad Serie Drücken Sie Menü, wählen Sie die Installation der Kontrolle basın.Buradan, wählen Sie dann den Schlüssel zu Abschnitt ändern. Die Buchstaben B-Code seçiyoruz.Buraya k.ey. Wir treten 001FFF 00 1000000000000000 OK. & 220C Serie Orient 7004-7005 Starsat 190FTA Menü-Taste auf dem roten Kanal schreiben und Geschehen basın.Güncel password ‘drücken Sie OK MX-READER-FTA-CI und COMBO Yumatu Serie Biss Abschnitt 7 NBA TV zum Zeitpunkt der Online-00-1000000000000000 tun 001FFF OK Yumatu 8000 Serie, NBA TV Biss Schnittlinie Ident “ini 001FFF OK Anmelden TechStar 9000 TRT1 *** K.E.Y. Geben Sie den Abschnitt über biss ok Stellen Pfeile 1000000000000000 Redline-Serie für Menü + Installation + + wichtigsten Satelliten-SW-Update, drücken Sie auf die Pfeile. Botech USB 7300XFTA Drücken Sie die Taste Menü “Optionen”, zeigen Sie auf den Code im unteren Teil der wichtigsten 7799 Bearbeiten entfernt .. Biss und der höchste Punkt-Linie, Typ 1000000000000000 Botech auch 7200FTA 7799 Materialien und das Spiel-Menü nach dem u-Taste, um das Menü am unteren Teil des Code eingeben, organisieren … Blättern Sie in der oberen Zeile und geben Sie Biss 100000000000000. Anmelden Nextk.ey TRT1 vergessen Menü-Einstellungen-User-Session-Setup von 9844 Yazan Yere TRT1 als Beweis-BISS Namen OK-Ausgang TRT1 Yazin altina 1000000000000000 Uns ist OK. Metawere (Akai-Atlanta-Aciko-Taplin-Satech): Menü am unteren Rand ke.y. Abschnitt (oder Menü 9713) ke.y. Bearbeitung Biss Abschnitt 2.sıraya 1FFF 00: 1000000000000000 oder Im gleichen 000001 00: 1000000000000000 Planet Während das Gerät Informationen Gelb 7799 Bearbeiten Code in offenen gemeinsamen Schnittstelle. Asahi 10100. fta Nach der Installation an den Empfänger zu bringen auf die Werkseinstellungen zurücksetzen. Make türkischer Sprache Einstellungen Zum Aktivieren der Verschlüsselung der Fernbedienung gedrückt, während Sie im Hauptmenü, drücken Sie in der Reihenfolge 2 3 5 6. Geben Sie das Menü. Dieses Menü ist auf 5 hat (edit ***) und 6 (defauld laden ***) werden extra. Das Passwort ist 0000. Ändern von Passwörtern manuell bearbeiten *** dieses Menü zu schreiben. Geben Sie Ihrem Gerät.