Well as I have said before Lady Gaga scares me a little bit.  But, I takes courage to go out and wear what you want to wear.  This is about the music not the physical appearance.  ”The Fame Monster” is not really a new album it is more of an extension of last years release “The Fame.”  The latest installment is like Gaga’s previous work which is very pop and dance club related music.  It is  definitely more upbeat music for seven of the eight tracks.  But I do tend to have a soft spot for artists that include a string section in songs.  The song out of the seven that does include this is “Speechless.”  For some of you who watched the AMA’s, this song was the ending song in her performance.

So it really depends on who you are.  If you really like the dance club music you should buy all eight tracks.  But if you don’t really like the dance music then just get the “Speechless” track.   If you get the deluxe edition of this album “The Fame” album is the rest of the tracks on “The Fame Monster.”

I keep on thinking how it would be to rule the world.  In my mind, I have it envisioned as if the world was my puppet.  I’d be sitting indian style in the middle of space and just have all these strings on my fingers and I’d be controlling everything.

I would be a pretty bad ruler.  I never know what to do with my hands, so I can’t even imagine how I would handle it with strings attached to them.

That makes me think of that Nsync music video.  Yeah, you know.  You know.

I enjoy watching awards that show a tribute to music.  Even if it is an awards show that is voted on.  I would rather watch the performances on those because we all know it is the dumb ten year-olds that vote for those.  So, I just ignore the results.  I just got finished watching the American Music Awards.  There were many great moments and some head scratching moments.

I will start off with the fan voted awards.  The big winners were the late Michael Jackson and Taylor Swift.  Next I will go to the performance losers of the night.  First would be Rihanna.  I know she went through a bad year, but the performance was very messy.  The Second and last would be Adam Lambert.  I think it is good that there are artist out there that are open about their sexual preferences, but that was awkward.  It was a very screamy, pitchy performance.  I know a great songwriter Claude Kelly wrote this song, but I think he went a little skew with this one.

Now For the best performances of the night.  First would be Kelly Clarkson.  I an a big fan of songs that include orchestra strings.  They had changed this song because of the comparison to Beyonce, but this version is great.  I would like if Clarkson had done maybe a new song, but performing a different version is good.  Second would be Lady GaGa. Physically she scares me a little, but musically she is fantastic.  She proves that you should not judge by appearance and listen to the music.  It was great when she smashed her way in to the piano section.  Piano was a great choice to include.  Lastly was the great Whitney Houston.  The award of the night for her.  What is better that seeing a legend perform.  It is great to see her back again.  These three ladies also did what not many on the show did.  They performed on pitch and key.      I just wish the ending of the show was different.

Overall, It was an alright show.  The end went for too much shock value and could end up overshadowing the great performances in this show.  Congrats to all the winners and good night.  I hope…….

Respondendo a pergunta do f0ker a respeito de quando se usa unhex ou outras strings.

http://dev.mysql.com/doc/refman/5.0/en/string-functions.html

ASCII() Return numeric value of left-most character

BIN() Return a string representation of the argument

BIT_LENGTH() Return length of argument in bits

CHAR_LENGTH() Return number of characters in argument

CHAR() Return the character for each integer passed

CHARACTER_LENGTH() A synonym for CHAR_LENGTH()

CONCAT_WS() Return concatenate with separator

CONCAT() Return concatenated string

ELT() Return string at index number

EXPORT_SET() Return a string such that for every bit set in the value bits, you get an on string
and for every unset bit, you get an off string

FIELD() Return the index (position) of the first argument in the subsequent arguments

FIND_IN_SET() Return the index position of the first argument within the second argument

FORMAT() Return a number formatted to specified number of decimal places

HEX() Return a hexadecimal representation of a decimal or string value

INSERT() Insert a substring at the specified position up to the specified number of characters

INSTR() Return the index of the first occurrence of substring

LCASE() Synonym for LOWER()

LEFT() Return the leftmost number of characters as specified

LENGTH() Return the length of a string in bytes
LIKE Simple pattern matching

LOAD_FILE() Load the named file

LOCATE() Return the position of the first occurrence of substring

LOWER() Return the argument in lowercase

LPAD() Return the string argument, left-padded with the specified string

LTRIM() Remove leading spaces

MAKE_SET() Return a set of comma-separated strings that have the corresponding bit in bits set

MATCH Perform full-text search

MID() Return a substring starting from the specified position

NOT LIKE Negation of simple pattern matching

NOT REGEXP Negation of REGEXP

OCTET_LENGTH() A synonym for LENGTH()

ORD() Return character code for leftmost
character of the argument

POSITION() A synonym for LOCATE()

QUOTE() Escape the argument for use in an SQL statement

REGEXP Pattern matching using regular expressions

REPEAT() Repeat a string the specified number of times

REPLACE() Replace occurrences of a specified string

REVERSE() Reverse the characters in a string

RIGHT() Return the specified rightmost number of characters

RLIKE Synonym for REGEXP

RPAD() Append string the specified number of times

RTRIM() Remove trailing spaces

SOUNDEX() Return a soundex string

SOUNDS LIKE(v4.1.0) Compare sounds

SPACE() Return a string of the specified number of spaces

STRCMP() Compare two strings

SUBSTR() Return the substring as specified

SUBSTRING_INDEX() Return a substring from a string before the specified number of occurrences of the delimiter

SUBSTRING() Return the substring as specified

TRIM() Remove leading and trailing spaces

UCASE() Synonym for UPPER()

UNHEX()(v4.1.2) Convert each pair of hexadecimal digits to a character

UPPER() Convert to uppercase

Playing guitar is fun and can be fun to learn. This guide is help you in choosing your first guitar that you will be learning on.

Go to a local music store and look around. You will see many guitars. Electric guitars, solid body, hollow body, acoustic guitars, acoustic/electric guitars, travel guitars, and bass guitars. These instruments can range anywhere from about $50 USD to $5,000 USD. That’s right, you can
easily pay in the range of $5,000 for a non-electric, acoustic guitar. Go ahead and look up a “Martin D-45 guitar” for an example.

First, is the instrument going to be for an adult or a child/teen? Is it going to be properly taken care of by who owns it? Is it ever going to be taken anywhere? (Camping, over to a friend’s house, to a hotel room on a weekend getaway.)

Some of the higher priced guitars such as “Gibson”, “Fender”, “Martin”, or “Taylor” will hold their value and may even increase in value later down the road if they are properly taken care of.

Now we all know that children have been known to take on many projects only to never finish them. And this rings true for learning to play a musical instrument as well. I’ve seen young teens take up guitar only to discover the opposite sex 2 months into it and never pick it up again. The last thing you want to do is spend $1500 USD on a “Jackson USA Soloist” electric guitar and another $2,000 USD for a “Marshall” all tube half stack and have your son or daughter ding and scratch up the guitar only to find they loose interest in it in a few months.

So it is my recommendation that a first guitar for a child or teen should be UNDER $200 for the guitar itself. Then if in a year or two, your child is still playing it and has progressed, then you can justify spending about $850 USD for a new “USA Fender Stratocaster” and $500 – $700 for a decent combo amp. – Bass Guitar Chords -

Guitar Fretboard Notes
Guitar Fretboard Notes

Ellington-Strayhorn with Strings, two performances in February!

Monday, Feb. 8, at Jazz Salt Lake: The Quartet, joined by members of the Salt Lake Symphony Strings, performs the music of Duke Ellington and Billy Strayhorn, arranged for flute and jazz trio by Christopher Hughes, Bill Cunliffe and Mike Wofford. Joining me in the Quartet will be Mike Wofford, piano; Christoph Luty, bass and Jeff Hamilton, drums.  More information at www.jazzslc.com.

Saturday, Feb. 13, at the Newport Beach Jazz Party: The Quartet will perform with Orange County String Orchestra, again with a program of Ellington arranged for flute and jazz trio. I will be joined  again by Christoph Luty on bass, Jeff Hamilton on drums and Mike Wofford, piano. More information at www.newportbeachjazzparty.com.

Good Morning! I woke up really early because I was so excited after an incredible day yesterday. I am sitting here having a pumpkin bagel with our honey butter and some hot mulled cider. It really feels and tastes like fall! I’ll post the honey butter recipe on our website because it is so easy and so over the top.

Yesterday we had so much fun! We kicked off holiday shopping with a party at my house. I met wonderful women and was able to catch up briefly with old friends. I want to thank everyone who participated because it was a special day.

I tried out three new recipes. The first was fabulous – persimmons with prosciutto topped with balsamic and olive oil. The second was dried pears topped with pureed tomato, peppers and cream cheese and a dot of the balsamic. The third was goat cheese toasts topped with walnuts and rosemary drizzled with honey.  I’ll post all three on our website and we had some old favorites including; marinated flank steak, sweet potato fries and the baked brie with balsamic.

Sarah Oliver of Sarah Oliver Handbags had her sophisticated and whimsical handbags, knit by the ladies from the Redwoods Senior Community.

Joy Schiffmann of Bunnytail Blankets will be selling her cozy, colorful and weather-resistant baby blankets with endless uses including picnic blankets and capes.

Paula Escher and Barbara Fritz of Strings, Unique Necklaces will be displaying their collection of jewelry made of semi precious stones and pearls.

Donna Miller Casey of Snap To It Photography was showing her photo cards and her matted 5 x 7 and 8 x 10 photos, as well as Paola Casey’s smocked dresses from Chile.

Laurie Rohrbach of Lobird had beautiful printed paper with vintage inspired illustrations and custom stationary.

Suzanne Ingalsbe Interiors sold her hand-painted decorative items. 415-775-7078

Amy Kelly’s Pink Pineapple’s linens 415-812-2685 with Ann Gerard and Stella & Dot fashionable jewelry. 415-286-3692

Cathy Bennett showed her How Fast Time Flies, a “Scrapbooking 2.0″ website which allows you to make 12×12 pages for babies, weddings and other life milestones.

Usha Burns of UB Chic had her fabulous little purses, perfect for an evening out, plus handmade gift tags, bangles and shawls from NY. 415-653-8656

Sara Curran of Polka Dogs had her reversible handcrafted belts from exquisite ribbons…fabulous cosmetic bags and key chains.

Tina Schreiber of Velvet & Tweed had her adorable children’s clothing line, because growing up is a special occasion!

Plumpjack had cool wine accessories, wine club memberships, & goodies for the men in your life.

Cindy Helfrich of C Treasures with her vintage jewelry-embellished memo clip boards. 415-435-3860

Kim Meek of Sausalito Style had her preppy chic ribbon belts.

Alexandra Skillman of Vivanista was here to show off the beautiful website.

Thank you to everyone who helped make it possible!

Here’s a three-for-one special for you: A post about implementing the Levenshtein string distance algorithm in Scala AND refactoring it from an imperative style to a functional style AND I even throw in a short lesson on memoization. To make sure that our refactoring is correct and preserves the expected behavior, I’ll unit test the code along the way using ScalaTest. ScalaCheck, JUnit, or TestNG would work just as well, but I used ScalaTest.

First Things First

“What, exactly,” some of you may be asking, “is Levenshtein string distance? Some kind of Teutonic tailoring terminology?” Not at all. It’s a way of measuring how alike or different two strings of symbols are. For example, the string “sturgeon” is a lot more similar to “surgeon” than to “urgently”. “Sturgeon” and “surgeon” are only a single letter (t) apart. They have a string distance of 1. “Sturgeon” and “urgently” share some letters, but each has some letters not present in the other. So what’s their string distance? It’s not so obvious now.

String distance is useful. The use that most quickly springs to mind is spelling correction. If I type “computwr” a string distance algoritm could tell us that “computwr” is very close to the dictionary word “computer”. But there’s more to it than that. There are a lot of fuzzy problems in which you want to find which two sets of complex data are most similar. One way to solve a problem like that is to encode it into a string compare using string distance. For example, you could write a program to find pen strokes in an image and encode their shapes (up, curve left, down, angle right, etc) as a string which could be compared to known encodings for handwritten letters. By finding the closest matches you can create a handwriting recognition program. String distance is useful in DNA analysis, of course, recognizing patterns in signals, and a host of other situations.

The Levenshtein string distance algorithm was developed by Vladimir Levenshtein in 1965. It can easily tell us the distance from “sturgeon” to “urgently”. This algorithm breaks down string transformation into three basic operations: adding a character, deleting a character, and replacing a character. Each of these operations is assigned a cost, usually a cost of 1 for each operation. Leaving a character unchanged has a cost of 0. So to go from “sturgeon” to “surgeon” you leave the “s” unchanged for a cost of 0. Then you add a “t” for a cost of 1. All the other letters also remained unchanged, so the total cost is 1, just as we expected.

To change “sturgeon” to “urgently” is harder. They have the same number of letters, so we could just do a replacement on each one for a distance of 8. But is that the shortest distance? What if we try to re-use that “urge” from “sturgeon”? Can we re-use the “n”? Does that help? What about the “t”? We need an algorithm that we can follow.

The Grid

What we need is a way to find the cheapest combination of operations which changes the first string to the second. That’s the Levenshtein algorithm. It works like this. Write the first string vertically from top to bottom. To the right of each letter write 1, 2, 3, etc. Write a 0 above the number 1. Then write the second string horizontally and again add the numbers 1, 2, 3 etc. to the right of the 0. It will look something like this:

    u r g e n t l y
  0 1 2 3 4 5 6 7 8
s 1
t 2
u 3
r 4
g 5
e 6
o 7
n 8

That’s the first step. The grid remains un-filled-in at this point. Can you guess what the grid positions are going to hold? They are going to hold the cost to convert the various prefixes of “sturgeon” to the various prefixes of “urgently”. The position at the intersection of row r4, and the column a2, for example, will contain the cost to convert “stur” to “ur”. We fill in these positions (left-to-right then top to bottom) with the smallest of the following three numbers:

• The number above the current position plus one.
• The number to the left of the current position plus one.
• The above-left number if row letter and column letter are the same, or the above-left number plus one otherwise.

When we finish, the bottom right corner contains the cost to convert the first string to the second.

But Why? (Understanding the Algorithm)

Those are some shockingly simple rules! Let’s examine how they translate into string distance.

First, what are those numbers 0 to n that we write along the top and left? They’re not just indices. The numbers along the top represent the cost to convert the empty string to the various prefixes of “urgently”. The cost is 0 to convert “” to “”, 1 to convert “” to “u”, 2 to convert “” to “ur”, and so on. The numbers on the left are the cost to convert the prefixes of “sturgeon” to the the empty string . “” to “” is 0, “s” to “” is 1, and so forth. These costs are obvious. The only way to convert “” to “urgently” is to add eight letters. There’s nothing to delete, nothing to replace. The only way to convert “sturgeon” to “” is to delete all eight letters.

Each position, as we have established, represents the cost to convert the string of characters down the left side ending in the current row’s character into the the string of characters along the top ending at the current column’s character. Put another way, for any given position let’s call the current row’s letter A, and the current column’s letter B. If we use a colon (:) to indicate string concatenation then the beginning string, the one along the left of the grid, can be written Prefix1:A. So for our example word “sturgeon” if we look at a position in row e6 then Prefix1 is “sturg” and the final letter, which we’re calling A, is “e”.

So, speaking in terms of Prefix1, Prefix2, A, and B, we use the following inputs:

• The cost to change Prefix1 to Prefix2:B (the number above the current position).
• The cost to change Prefix1:A to Prefix2 (the number to the left).
• The cost to change Prefix1 to Prefix2 (the above-left number).

If we know the costs of these three conversions we can find the cost to change Prefix1:A to Prefix2:B using this logic:

• We know that if converting Prefix1 to Prefix2:B has a cost of X, then Prefix1:A can be converted to Prefix2:B for the cost of X plus the cost of deleting A, or X + 1.
• We know that if converting Prefix1:A to Prefix2 has a cost of Y, then Prefix1:A can be converted to Prefix2:B for the cost of Y plus the cost of adding B, or Y + 1.
• We know that if converting Prefix1 to Prefix2 has a cost of Z, then Prefix1:A can be converted to Prefix2:B for the cost of Z plus the cost of replacing A with B, or Z + (0 or 1 depending on whether A = B).

If you understand the above logic, then you understand this really neat algorithm. It’s a quintessential example of dynamic programming. The solution is built up by solving simpler problems. You start with the trivial case of converting to and from the empty string, and then you build up the solution for the prefixes until you have the complete solution.

In the grid’s initial configuration there is only one location for which we know all three costs and that is row s1, column u1. That’s the only space for which all three neighboring values (above, left, and above-left) are populated. After we fill in this one, there are two more spaces available to us. Those are (t2, u1) and (s1, r2). Ordinarily, though, the spaces are populated line by line.

A Simple Example

Let’s do a quick example by hand. Then we’ll take a stab at implementing it in code. What’s the string distance from “hat” to “tape”? First, our empty grid:

    t a p e
  0 1 2 3 4
h 1
a 2
t 3

The first space is row h, column t. The letters are different so our choices are 1 + 1 (above), 1 + 1 (left), or 0 + 1 (above-left). 0 + 1 is the smallest value, so the first space gets populated with 1. The next space has choices 2 + 1 (above), 1 + 1 (left), or 1 + 1 (above-left). 1 + 1 is the lowest, so we fill in the second space with 2. Once we finish the row, we have this:

    t a p e
  0 1 2 3 4
h 1 1 2 3 4
a 2
t 3

The next space is row a, column t. Our choices are 1 + 1 (above), 2 + 1 (left), or 1 + 1 (above-left). 1 + 1 is the smallest value, so the space gets populated with 2. The next space has choices 2 + 1 (above), 2 + 1 (left), or 1 + 0 (above-left). Why 1 + 0? Because the above-left value is 1 and both letters for this space are “a” so we can replace “a” with “a” for free. Go ahead and finish the whole grid. This is the result:

    t a p e
  0 1 2 3 4
h 1 1 2 3 4
a 2 2 1 2 3
t 3 2 2 2 3

The strings “hat” and “tape” have a distance of 3.

Some Code, Finally

As fascinating as Levenshtein distance is, and as much more as there is to say on the topic, the time has come to write some code. Here’s a Scala implementation that is very close to the pencil-and-paper approach that we just performed.

import scala.Math.min
import scala.Math.max

object StringDistance {
  def stringDistance(s1: String, s2: String): Int = {
    def minimum(i1: Int, i2: Int, i3: Int) = min(min(i1, i2), i3)

    val dist = new Array[Array[Int]](s1.length + 1, s2.length + 1)

    for (idx <- 0 to s1.length) dist(idx)(0) = idx
    for (jdx <- 0 to s2.length) dist(0)(jdx) = jdx

    for (idx <- 1 to s1.length; jdx <- 1 to s2.length)
      dist(idx)(jdx) = minimum (
        dist(idx-1)(jdx  ) + 1,
        dist(idx  )(jdx-1) + 1,
        dist(idx-1)(jdx-1) + (if (s1(idx-1) == s2(jdx-1)) 0 else 1)
      )

    dist(s1.length)(s2.length)
  }

Do you see what I mean when I say it’s close to the pencil-and-paper approach? We actually construct a two-dimensional Array to represent the grid we drew earlier. It’s a very literal implementation.

To explain the code briefly, we declare a singleton StringDistance having a single method called stringDistance. Within this method we declare a 3-argument minimum method. (I wonder why there’s no “def min(params: Int*): Int” defined in scala.Math.) Then we create an array called “dist” and populate the top row and leftmost column in lines 8-11. The for loop on line 13 cycles through each array position from left to right then top to bottom, and populates them according to the Levenshtein logic. Finally, once the grid is filled in we return the number in the bottom right position.

The job’s not done yet, of course. We haven’t written our unit tests. Here’s the test I wrote:

import org.scalatest._

class StringDistanceSuite extends FunSuite with PrivateMethodTester {

  test("stringDistance should work on empty strings") {
    assert( StringDistance.stringDistance(   "",    "") == 0 )
    assert( StringDistance.stringDistance(  "a",    "") == 1 )
    assert( StringDistance.stringDistance(   "",   "a") == 1 )
    assert( StringDistance.stringDistance("abc",    "") == 3 )
    assert( StringDistance.stringDistance(   "", "abc") == 3 )
  }

  test("stringDistance should work equal strings") {
    assert( StringDistance.stringDistance(   "",    "") == 0 )
    assert( StringDistance.stringDistance(  "a",   "a") == 0 )
    assert( StringDistance.stringDistance("abc", "abc") == 0 )
  }

  test("stringDistance should work where only inserts are needed") {
    assert( StringDistance.stringDistance(   "",   "a") == 1 )
    assert( StringDistance.stringDistance(  "a",  "ab") == 1 )
    assert( StringDistance.stringDistance(  "b",  "ab") == 1 )
    assert( StringDistance.stringDistance( "ac", "abc") == 1 )
    assert( StringDistance.stringDistance("abcdefg", "xabxcdxxefxgx") == 6 )
  }

  test("stringDistance should work where only deletes are needed") {
    assert( StringDistance.stringDistance(  "a",    "") == 1 )
    assert( StringDistance.stringDistance( "ab",   "a") == 1 )
    assert( StringDistance.stringDistance( "ab",   "b") == 1 )
    assert( StringDistance.stringDistance("abc",  "ac") == 1 )
    assert( StringDistance.stringDistance("xabxcdxxefxgx", "abcdefg") == 6 )
  }

  test("stringDistance should work where only substitutions are needed") {
    assert( StringDistance.stringDistance(  "a",   "b") == 1 )
    assert( StringDistance.stringDistance( "ab",  "ac") == 1 )
    assert( StringDistance.stringDistance( "ac",  "bc") == 1 )
    assert( StringDistance.stringDistance("abc", "axc") == 1 )
    assert( StringDistance.stringDistance("xabxcdxxefxgx", "1ab2cd34ef5g6") == 6 )
  }

  test("stringDistance should work many operations are needed") {
    assert( StringDistance.stringDistance("example", "samples") == 3 )
    assert( StringDistance.stringDistance("sturgeon", "urgently") == 6 )
    assert( StringDistance.stringDistance("levenshtein", "frankenstein") == 6 )
    assert( StringDistance.stringDistance("distance", "difference") == 5 )
    assert( StringDistance.stringDistance("java was neat", "scala is great") == 7 )
  }

}

It tests several special cases as well as the general case. All we have to do is compile our StringDistance object and the StringDistanceSuite unit test, fire up the scala interpreter and run the test:

scala> (new StringDistanceSuite).execute()
Test Starting - StringDistanceSuite: recursiveStringDistance should work on empty strings
Test Succeeded - StringDistanceSuite: recursiveStringDistance should work on empty strings
Test Starting - StringDistanceSuite: recursiveStringDistance should work on equal strings
Test Succeeded - StringDistanceSuite: recursiveStringDistance should work on equal strings
Test Starting - StringDistanceSuite: recursiveStringDistance should work where only inserts are needed
Test Succeeded - StringDistanceSuite: recursiveStringDistance should work where only inserts are needed
Test Starting - StringDistanceSuite: recursiveStringDistance should work where only deletes are needed
Test Succeeded - StringDistanceSuite: recursiveStringDistance should work where only deletes are needed
Test Starting - StringDistanceSuite: recursiveStringDistance should work where only substitutions are needed
Test Succeeded - StringDistanceSuite: recursiveStringDistance should work where only substitutions are needed
Test Starting - StringDistanceSuite: stringDistance should work many operations are needed
Test Succeeded - StringDistanceSuite: stringDistance should work many operations are needed

scala>

Refactoring: Reduced Memory Usage

The code passes all the tests, so let’s take things a step further. One shortcoming of our implementation is that it can require a lot of memory. That array has to be of size (n+1)*(m+1) where n and m are the lengths of the two strings we’re comparing. If you want to apply the method to strings that are a few hundred characters long (or longer) then you’re starting to talk about some serious memory requirements. How can we reduce the amount of memory required? Can you think of a way?

Once we complete one row of the grid, we use it again as an input when we compute the next row. But after that we’re done with it. Why leave it to clutter the heap? Let’s tweak our implementation slightly. Try rewriting the method using only two rows. Fill the first row with the initial 0, 1, 2, etc. Then use one to compute the other over and over. Think about how you would implement this, then have a look at my solution below.

  def stringDistance(s1: String, s2: String): Int = {
    def minimum(i1: Int, i2: Int, i3: Int) = min(min(i1, i2), i3)

    var dist = ( new Array[Int](s1.length + 1),
                 new Array[Int](s1.length + 1) )

    for (idx <- 0 to s1.length) dist._2(idx) = idx

    for (jdx <- 1 to s2.length) {
      val (newDist, oldDist) = dist
      newDist(0) = jdx
      for (idx <- 1 to s1.length) {
        newDist(idx) = minimum (
          oldDist(idx) + 1,
          newDist(idx-1) + 1,
          oldDist(idx-1) + (if (s1(idx-1) == s2(jdx-1)) 0 else 1)
        )
      }
      dist = dist.swap
    }

    dist._2(s1.length)
  }

This one uses a Pair (also called a Tuple2) containing two one-dimensional arrays, instead of a 2*(n+1) array. Pair happens to have the very handy “swap” method which we can use to trade out the rows when we’ve finished one and are ready to compute the next.

This is where our unit tests really show their worth. No need to wonder whether this new code really does work. We just recompile, run the tests again, and we can see that the code still gives us the expected results.

Refactoring: Recursion, Kind Of

What are some other ways we could write this code? Can it be improved? I thought I would try to replace the iteration in the previous implementations with recursion. Here’s what that code looks like:

  def stringDistance(s1: String, s2: String): Int = {
    def newCost(ins: Int, del: Int, subst: Int, c1: Char, c2:Char) =
      Math.min( Math.min( ins+1, del+1 ), subst + (if (c1 == c2) 0 else 1) )

    def getNewCosts(s1: List[Char], c2: Char, delVal: Int, prev: List[Int] ): List[Int] = (s1, prev) match {
      case (c1 :: _ , substVal :: insVal :: _) =>
        delVal :: getNewCosts(s1.tail, c2, newCost(insVal, delVal, substVal, c1, c2), prev.tail)
      case _ => List(delVal)
    }

    def sd(s1: List[Char], s2: List[Char], prev: List[Int]): Int = s2 match {
      case Nil => prev.last
      case _ => sd( s1, s2.tail, getNewCosts(s1, s2.head, prev.head+1, prev) )
    }

    (s1, s2) match {
      case (`s2`, `s1`) => 0
      case (_, "") | ("", _) => max(s1.length, s2.length)
      case _ => sd(s1.toList, s2.toList, (0 to s1.length).toList)
    }
  }

It’s a pretty naïve implementation, actually. It just replaces the the repetition of the two for loops with the repetition of the recursion of the two methods sd and getNewCosts. The sd method is even tail-recursive, allowing scala to optimize it. It does the same basic thing as the for loop version, though. It recurses through the characters of a row in the getNewCosts method, and it recurses through the rows of the grid in the sd method.

It looks more complicated than the previous implementations. It’s harder to read. But it passes our unit tests, so we can be pretty sure it’s correct.

Refactoring: List Methods

After the last implementation, I thought it looked a little sloppy. I wondered whether I could improve the situation by using some of the many useful methods built into scala’s List class. Here is the comparatively brief code that resulted:

  def stringDistance(s1: String, s2: String): Int = {
    def sd(s1: List[Char], s2: List[Char], costs: List[Int]): Int = s2 match {
      case Nil => costs.last
      case c2 :: tail => sd( s1, tail,
          (List(costs.head+1) /: costs.zip(costs.tail).zip(s1))((a,b) => b match {
            case ((rep,ins), chr) => Math.min( Math.min( ins+1, a.head+1 ), rep + (if (chr==c2) 0 else 1) ) :: a
          }).reverse
        )
    }
    sd(s1.toList, s2.toList, (0 to s1.length).toList)
  }

Like I say, it’s brief. Those List methods give you a lot of mileage.

Refactoring: Real Recursion

The more I looked at my previous attempt at a recursive solution, the more I realized how hare-brained it was. It wasn’t real recursion. It was just iteration using the stack. So I went back to the drawing board. If I want to know the final answer, the value in the bottom right position, how do I get it? I apply my three rules to the above, left, and above-left positions. How do I get those positions? Apply the rules again. That’s real recursion. Here’s my first stab at it:

  def stringDistance(s1: String, s2: String): Int = {
    def min(a:Int, b:Int, c:Int) = Math.min( Math.min( a, b ), c)
    def sd(s1: List[Char], s2: List[Char]): Int = (s1, s2) match {
      case (_, Nil) => s1.length
      case (Nil, _) => s2.length
      case (c1::t1, c2::t2)  => min( sd(t1,s2) + 1, sd(s1,t2) + 1,
                                     sd(t1,t2) + (if (c1==c2) 0 else 1) )
    }
    sd( s1.toList, s2.toList )
  }

Now, THAT is a nice looking recursive function. That’s more like it. See the pattern match block? If we try to convert from any string to the empty string or from the empty to a non-empty string then we just use the string length. You see? That takes care of the positions along the top and left of the grid. All the others are determined in the last case. That last case just applies our three rules. That is so short and simple. It’s a thing of beauty.

The only problem? It doesn’t work.

It’s technically correct. It will return correct answers … eventually. Or, rather, I think it will. I can’t be sure because it’s too slow to complete my unit tests! For anything but very short inputs (4 or 5 characters), the function takes a long time to return. Why? Let’s look at how many recursive calls are made for some inputs.

If we pass use strings “a” and “b” we pass by the “(_, Nil)” and “(Nil, _)” cases in the first call to function sd, because both our strings (Lists, actually) are non-empty. This results in three more calls to sd. Each of these three calls includes an empty List of characters, so there is no more recursion. That’s a total of four calls to sd for strings “a” and “b”.

What about “ab” and “xy”? Think about it for a moment? Step through the function in your head. How many calls to sd will there be for “ab” and “xy”?

Have you done it? I count 19. What about “abc” and “xyz”? I’ll save you the trouble. It’s 94. For length 4 strings it’s 481. For length 5 it’s 2524. Length 6 is 13,483. Then 73 thousand, then 400 thousand, then 2 million and so forth. Why so many calls? Each position in the grid is computed using all the positions to the left and all the positions above the current position. So a position in the top left will be computed and recomputed many times.

There is a way to get around this, of course. You probably already have some ideas. We’re going to do something called memoization. When you memoize a function, you make it remember results that it computed previously without having to actually recompute them. I’ll do that by caching results in a map. The map’s key is a Pair of List[Char]s, the inputs to my inner function sd, and its data is an Int, the return type of sd. I will modify sd to first check the map to see if the result for the current parameters has already been cached. If so, we simply return it. If not, we compute the value, cache it, and return it.

  def stringDistance(s1: String, s2: String): Int = {
    val memo = scala.collection.mutable.Map[(List[Char],List[Char]),Int]()
    def min(a:Int, b:Int, c:Int) = Math.min( Math.min( a, b ), c)
    def sd(s1: List[Char], s2: List[Char]): Int = {
      if (memo.contains((s1,s2)) == false)
        memo((s1,s2)) = (s1, s2) match {
          case (_, Nil) => s1.length
          case (Nil, _) => s2.length
          case (c1::t1, c2::t2)  => min( sd(t1,s2) + 1, sd(s1,t2) + 1,
                                         sd(t1,t2) + (if (c1==c2) 0 else 1) )
        }
      memo((s1,s2))
    }

    sd( s1.toList, s2.toList )
  }
}

There. That uglies up my function somewhat, but at least it’s usable now. And it passes my unit tests, so I’m reasonably assured that it’s right.

Memoization only works if you expect the same result for each identical function call. If your function takes input from stdin, for example, you can’t memoize that. Or if it has a random component. Or if, for any other reason, its return value is not always the same for the same inputs. You can memoize functions in different ways. There’s a post on Michid’s Weblog about a more general solution, a memoizing class which wraps existing functions to give you a memoized version.

PHEW!

Ok, I’ve tried to keep my rambling to a minimum in this post but it’s still a doozy. The things I wanted to get across are:

• The usefulness of Levenshtein distance in solving a variety of problems.
• How to understand the Levenshtein distance algorithm and why it works.
• How to use unit tests to improve your code while maintaining some assurance that the new code still has the correct behavior.
• Some of the different ways of implementing Levenshtein.

In the end, I think I like the second implementation (the one that switches out the two rows) and the last implementation the best. The second one seems to have good performance. I did some informal performance tests and it has a good mix of performance and simplicity. The last one, the memoized recursive one, appeals to me because it is in a more functional style and still has respectable performance.

Don’t forget to subscribe to my RSS feed, or follow this blog on Twitter.
Copyright © 2009 Matthew Jason Malone

Garwulf at the Huntsman’s Lodge did a way better write up on a hunter powerauras setup than I ever could. In fact, I intend to switch over to his settings when I get home tonight, they’re so much prettier than mine.

קצת נעלמתי, אני מרגישה שחולפת אותי סופת הוריקן. ישנם דברים כה רבים שאני רוצה לכתוב עליהם, אך הם נמצאים בחלל הסערה ואני לא מצליחה לתפוס אותם.  התוצאה היתה דממה ורבאלית. וכעת למרות הסערה המוחית אנסה לתפוס את המעופפים ולהוריד אותם אל עולם המילים והאימג’ים.

מספר שני ם אחורה  הזדמן לי לדלות מקופסה עמוסת קלטות (כן, כן קלטות) סרט שנשלח לחברה שהיתה חברה בועדת שיפוט זו או אחרת. הסרט נחקק בזכרוני ומאז אני מחפשת ומחפשת אותו כדי להראות אותו לסטודנטים שאני מלמדת, לחברים שקולנוע מעיניינם ובכלל להכיר לעולם סביבי סרט עם איכויות אחרות. הסרט הינו סרט אנימציה ויחודו בעיני בכך שכל הדמויות המשוחקות בו הן מריונטות. כמו כן הסרט הינו הרפתקאה ודרמה, אך מה שנחקק בזכרוני מהסרט הוא התרגום הנפלא לאופן בו דמויות המריונטה נולדות ומתות. הסיפור מסופר מתוך דמות בובות המריונטה, שהיא בובה על חוט. למשל בסרט הזה אין גגות , כיוון שאחרת איך ינועו ה”שחקנים”. כאשר דמות מתה, המוות מתבטא בחיתוך החוט המתחבר לקודקודה של הדמות. (אני לא אמשיך על מנת לא להרוס את הצפיה בסרט).

לדעתי זהו סרט עם דוגמא מעניינת לבחון בניית דמות , זהותה, חייה ומותה מתוך ה”שחקנים”  והאופיים המיוחד של השחקים.

שמו של הסרט STRINGS

סרט נוסף שחזר לתודעתי בעקבות צפיה בסרט, 500 הימים של סאמר. הינו הסרט Brick

ישבתי בקולנוע וניסיתי להזכר מנין זכורות לי הפנים החיוורות של השחקן הראשי והמבט הילדותי והעמידה הגמלונית. בסוף נפל האסימון והזכרון עלה באוב.

אחד הדברים שנחרטו בזכרוני בהקשר של הסרט היו זויות הצילום החדות והלא מקובלות והריקוד המרתק בין ויזואל לסאונד. הסרט נעשה בסגנון הפילם נואר, אשר אחד ממאפייניו הוא הסגנון הויזואלי הדרמטי הבא להדגיש את המתח בעלילה.

הסרט האחרון שאני רוצה לכתוב עליו דווקא כן הגיע לקולנוע בארץ. את הסרט העלילתי ראיתי בסינמטק תל אביב לפני מספר שנים, אני זוכרת שיצאתי מהסרט נפעמת, בגלל האבחנות הקטנות והמדויקות שלו לרגעים הקטנים של החיים, איך מעבירים זמן מת?תרגום של פרסונות שונות באופיין לשאלה מה עושים כאשר צריך להרוג זמן? מעל כל האבחנות המרתקות הללו שנובעות מהתבוננות מעמיקה על אנשים ודפוסי התנהגות שלהם. אנחנו מכירים את גיבור העלילה ואת דרכו שלו להרוג את הזמן, הצילומים היפייפים של הקפאת הזמן והאטתו מרגשים כל פעם מחדש כאשר הם קורים במהלך הסרט.

אני יצאתי מההקרנה מחויכת ובדרכי החוצה מהסינמטק קלטתי באוזני שאינן חדות בדר”כ מבקר אחד המציין שזוהי ורסיה של סרט סטודנטים קצר שעבר עיבוד לסרט עלילתי, ולדעתו הסרט הקצר הרבה יותר חזק ומדויק ברושם שהוא משאיר. עם ההערה הזו מיהרתי לביתי לחפש אחר אותה גרסה ראשונה של הסרט. לאחר שצפיתי בגרסה הקצרה, הבנתי למה התכוון אותו הבחור, בעבר נטיתי להסכים עם אבחנותיו ויחד עם זאת הזמן שעבר מאז שצפיתי בשניהם ועד עתה גרם לי לחשוב על כך, שהסרט העלילתי הופך את האבחנות לגבי זמן נגישות יותר לקהל הצופים הרחב ובצורה כזו יותר אנשים יוכלו להנות מהסרט הקטן והרענן הזה. והרי מטרת היוצרים לקרב את יצירתם תוך התפשרות מועטה ככל האפשר אל העולם שם בחוץ, זה שלא יושב בין כרי עננים ורודים וחולם את חלומותיו.

cashback

http://www.youtube.com/watch?v=xTG7u1R6cUQ&feature=related

brick

http://www.youtube.com/watch?v=3cVzHeJ0Z3I

ומשחק טריוויה ממש ממש שווה של הבי.בי.סי

http://www.bbc.co.uk/schools/ks2bitesize/games/questionaut/pop.shtml

When I was in the 3rd grade I took violin lessons.  I absolutely loved it!!! I had recitals made my mom nervous as heck before them because I was a nervous wreck.  Then calmly stand before the audience and play my piece as if I was never scared.  HAHA those were good times!!!

2 years later my instructor got ill and could not return and being in a very small town there was not anymore options for an instructor so my time as a violinist ceased.

Today I was hanging out with a friend and she remarked how no one plays the violin anymore and how she liked the sound of the instrument.  It reminded me of my short lived time playing the violin.

This instrument along with all strings are my fav.  I recently started playing at the guitar thanks to some great friends buying me a great Christmas present and the piano I received as a result of the passing of my dad.  These instruments are soothing to the soul.

I just miss my violin but I am not sure I can remember how to play it but I would try.  It would add to my collection of instruments I play at. 

Oh how i miss you… Violin!!!

Versión coral

Here is the link for my talk on Halloween safety for kids  (decorations, costumes) and Safe Trick-or-Treating on Healthradio.

Here is the album review I promised on my twitter yesterday!  Before I start, once again I want to thank you all for supporting my blog, both my music reviews and my personal entries.  I really appreciate all the views and I hope that you’ll keep it locked here because I ain’t stoppin’! Thankyou.

You already know what I think of Russian Roulette, and the other 3 songs we’ve heard already from Rated R.  Generally, they portray a darker, edgier side to Rihanna, both in the production (deeper, more menacing beats) and lyrical content that includes a bit of cursing, a lot of swagger and references to pain, trials and tribulations.  ”Russian Roulette”, “Wait Your Turn” and “Hard” are more or less indicative of the album as a whole.  In contrast to her previous smash Good Girl Gone Bad, it’s a lot less uptempo.  The songs are mainly midtempos and ballads, which may alienate a lot of fans who want her faster, danceable material (though “Hard” and “Rude Boy” cater to these needs, and do so well with swagger lyrics – the latter seeing Rihanna come on to a ‘rude boy’ as if she were the guy who is gonna “put it on you”).  However, the slower material allows for two major things: one, to prove that Rihanna can actually sing.  Okay, she’s no Beyoncé, but she holds her own a lot better than many people might expect.  ”Russian Roulette” and closing standout “The Last Song” don’t employ lots of vocal runs, but they emphasise strong, clear vocals that prove Rihanna’s got a voice as well as a body – btw. the artwork for this era is immense! – and also go well with the more emotionally searching and vulnerable material.  Two, it allows for Rihanna to delve into her pain, and although it’s never made explicit that she’s referencing her love, abuse and love lost with Chris Brown, songs such as “Stupid In Love” and the epic “Cold Case Love” immediately bring that whole affair to mind.

Not every song is concerned with love lost.  ”Te Amo” is about a girl who’s infatuated with Rihanna, and its undulating beats have been beefed up slightly on the album version to make it more hypnotic and possibly (along with “Rude Boy”) the song that would have slotted in nicely on Good Girl Gone Bad.  ”Rockstar 101″ is backed up by Slash’s guitar work and like “Hard” and “Wait Your Turn”, it demonstrates Rihanna’s confidence in herself – something she perhaps wants to emphasise.  She is fierce!  However, compared to some of the other tracks, “Rockstar 101″ falls somewhat flat, as it doesn’t have as much depth as the emotionally-charged midtempos, nor does it ring as true as the harder-knocking songs.  It does demonstrate that Rihanna is not an urban artist – she’s a pop singer who encompasses a range of music. On this album, she combines elements of rock, pop, R&B and melds them together to create a dark album that works for the most part.  And credit goes to her for trying to improve on each album – like Good Girl Gone Bad, the amount of filler on the disc is fairly minimal (in contrast to her first two records) and she’s tried to do something different that has evolved as she has as a person.  So I must applaud that.

A couple of the ballads such as “Stupid In Love” and “Photographs” (which benefits from will.i.am’s synthed beats that kick in midway) are perfectly solid, but pale in comparison to the best tracks.  These are, in a nutshell, first single “Russian Roulette”, “Fire Bomb”, “G4L”, “Cold Case Love” and “The Last Song”.  These all work because Rihanna is putting herself out there vocally and emotionally.  The producers do a fantastic job (praise must go in particular to Justin Timberlake and The Ys’ work on “Cold Case Love”, which shows a gradual building of beatboxing, standard beats, guitars and strings to an epic climax that fades out by itself and underline Rihanna’s pain at a love misfired – “Release me now ’cause I did my time”) more or less throughout, but Rihanna herself carries the songs.  ”Fire Bomb” has been compared to something by Kelly Clarkson, but in my opinion it knocks much harder and is a compelling contrast to expectations – most people would expect a club banger from the title, when in fact it’s a slow pop/rock ballad which essentially says “if I’m going down in flames, you’re coming with me”.  ”G4L” is one of the darkest songs which shows Rihanna pledging to be “down 4 life”, ride or die until the end.  The off-key tweaks at the beginning signal something mysterious, and the lyric “I lick the gun when I’m done ’cause I know that revenge is sweet” is one of the best opening salvos I can remember.  The track brings to mind the tiny gun tattoos on the sides of Rihanna’s breasts, demonstrating that even if she may be a sweet person on the surface, she’s also a strong and determined one – her attitude is reflected in her music as much as her body art.

“The Last Song” was the track that stood out to me most from listening to the 30-second snippets, and it doesn’t disappoint – it’s a perfect closer to the album, not only in name but in texture also.  It employs a soaring guitar and heartwrenching lyrics, chronicling the realisation of a breakup.  ”The sad song ends up being the last song you’ll ever hear.”  Rihanna’s spare vocals almost seem to cry the lyrics throughout the track, and the buildup throughout the song until near the end where all the instruments fade out is done perfectly.  Rihanna said that she wanted Lil’ Wayne and Kings Of Leon to like her album, demonstrating her desired blend of urban and rock. The album is definitely a mélange of styles, but apart from “Hard”, I don’t see enough hip-hop for Weezy to connect with, and the rock elements are nowhere near as indie-pop as Kings Of Leon.  However, the soaring guitars provide something edgier and deeper within the context of a pop album, and the hard-hitting beats and synths knock plenty – the combination of which provide something quite extraordinary and special within itself.  Rihanna should be proud of this record.

Rated R has a focused aggression to it that rings truer than it did on Good Girl Gone Bad. Despite the lack of uptempo smashes, it’s a fantastic record that hopefully will have as much repeat-play value as her previous record.  Whether it’s because of her personal struggles, maturity as a young woman or desire to experiment musically (probably a combination of all three), Rated R shows growth.  I pray that her label doesn’t re-release the album, since it’s perfect as it is and comes across as something sincere, rather than designed to make money as a light pop confection.  Why I’m impressed with Rated R, beyond the simple fact that most of the songs are solid or better, is because it’s cohesive.  All the songs work together to make the album more than the sum of its parts.  It has a big emotional impact, and it sets a musical mood (dark, edgy and yet heartfelt) that doesn’t let up throughout – in her own words, from “Hard”, “that Rihanna rain/reign”.  I didn’t know if she had it in her to best Good Girl Gone Bad, but even if it doesn’t have as many number 1 smashes and addictive beats, Rated R is a musical step forward that I personally value that little bit more.

Short Guide to Changing Strings on an Electric Guitar

Everybody knows how to change strings on an electric guitar.   Elementary, no?  Still, it’s an entirely different task when it comes to changing strings properly and on different types of bridges.

Most guitar players tend to overlook it, but one of the most important contributors to having a good guitar sound has to do with how the guitar is set up and adjusted. A good set up will result in maximum playing comfort and tuning precision, i.e. it will allow you to bring the best out of the instrument. When it comes to the set up of a guitar, we usually think about the neck bow, the action (strings height) and the harmonics (tuning), while neglecting the actual stringing. I’ve met too many guitarists who complained about their instrument’s tuning and failed to see the mess of strings their tuners were–making it a feat for the guitar to stay in tune.

The goal of this article is to explain to you (again!) the most important thing a guitarist ought to know: how to change the strings of his/her instrument.

Basic Principles

Basically, changing a guitar string means fastening one end to the tremolo system and the other end to the tuner (a.k.a. machine head or tuning key) so you can wind it until you get the desired note. In order to have maximum tuning stability, the basic principle is to limit chafing at both points as much as possible, i.e. at the machine heads on the headstock and at the bridge (be it with a tailpiece or a tremolo system). Once the guitar has been tuned, the main goal is for it to stay in tune while you play, in other words, that the strings return to their original position after using the tremolo arm.

Required Materials

• New strings.
• Cutting pliers.
• String winder.
• Optional: Depending on the tremolo system you might need an Allen wrench.

You’ll need the cutting pliers to snip off the the excess string protruding from the tuning peg once the strings have been installed. Apart from the fact that it looks awful, leaving long string ends bulging from the headstock can be dangerous to yourself and the other musicians you play with. A steel string could easily pierce through the flesh or under a fingernail or even poke someone’s eye out…

The string winder is an optional but strongly recommended tool. It allows you to wind the strings steadily around the tuning pegs and makes string setup much easier. You can get one for a couple of bucks in any music store.

Before Reaching for your Beloved Guitar

We recommend that you change strings one by one, unless you need to remove all strings at once to adjust the neck, service the fingerboard, etc. This allows you to avoid nasty situations, like the one depicted here.

In this specific example, a false move could result in the need to adjust the tune-o-matic bridge all over again.

Moreover, for guitars with floating tremolo systems (Floyd Rose and similar), this is the only one way you’ll be able to spare yourself several hours dedicated to tuning the guitar after having changed the strings.

Try to use strings with the same gauge (= thickness) as the string set you are replacing and, where possible, use the same brand. That’s the best way to go if your guitar is properly set up. Obviously, if you plan to change the string gauge, it’s a good idea to set up the guitar accordingly.

Ready? Let’s go!

Step by Step (in general)

1. Bridge: on most tremolo and tailpiece systems, you simply have to feed the string through the tailpiece or through the body of the instrument.

Feed the string through the holes…

… the string comes out through the saddles.

2. Pull the new string…

3. … and feed it through the tuning peg hole.

5. Use this kink to fasten the string around the tuning peg and turn the string winder with one hand while you tighten the string with the other, so that the string starts to wind around the tuning peg. Be sure to turn the tuner in the right direction: guitar headstocks are built so that the string goes straight from the nut to the tuner axis; on three-on-a-side tuner configurations, the headstock is built so that the strings are wound on the inner side.

6. Continue winding the string around the tuning peg so that the first turn is made above the string end coming out of the peg hole.

7. Continue tightening the string and turning the string tighter so that the string winds underneath the string end coming out of the peg hole.

8. Continue turning the string winder until the string is tight enough. Turn the tuner with your hand to tune the guitar.

9. Check the result: you should see the string end coming out of the tuning peg with the first coil above it and all following coils properly and neatly wrapped below it around the peg.

There must be at least three full coils around the tuning peg. It is very important for the winding to be as neat as possible, that way you avoid the string from moving around the tuner axis, the string finds its position naturally and the guitar stays better in tune.

10. Last step: in order for the coils to find their right position, gently pull on the string. The tuning ought to change a bit (the string will sound lower). Repeat (tune the string and pull on it) until it has no effect on the tuning.

11. Finally, cut the excess string protruding from the tuner.

12. Now, repeat all steps for each string!

Now let’s take a look at how this is done on other more complicated tremolo systems…

…

Conclusion… and some tips!

As you can see, restringing a guitar is not very difficult if you know how to do it. So take your time to do it calmly at home instead of doing it in a rush right before your gig or recording session is about to start.

Last but not least, some extra tips:

I personally fell in love with locking tuners because they are very easy to use, allow me to change strings in no time and play right away without the fear that my guitar won’t stay in tune.

The tuning stability can be improved by lubricating the nut with graphite (rub a very fat pencil where the strings make contact with it) or specialized products (Nut Sauce, etc.) that allow the strings to slide freely through the nut. If you feel the tuners don’t “respond properly” try this solution first instead of running to your nearest guitar tech.

That’s it for today! You have no excuses now, so I don’t want to see spaghetti-like-strings anymore! Don’t hesitate to send me your comments and questions.

To read the full detailed article see:  Changing Strings on Electric Guitars

I Am Surprised!

Yes people.. Our Choir Conductor at the Deer Park United Church, Loise gave me an early birthday/Christmas present..

Guess what? It’s a 1989 Saturn guitar..

It was well taken cared off, well polished, and what else could best describe it rather than saying it’s a “vintage collector’s item”.. Oh well, not that vintage though coz 1989 is just like 21 years ago, but considering it survived that long and still looked very much like a brand new one makes it valueable..

Just the thought that the guitar was made when (or even before) I turned 8 years old and was handed down to me now, barely a month before I turn 28, is like having an old rockstar giving me his precious possession.. Astig!! Astig!!

So, to Loise, thanks a lot and don’t worry, I’ll keep your gift safe and well taken cared off, the way you kept and took care of it in the last 21 years..

Comandos Basicos :

{ Limpar Lista }

Código:
ListBox1.DeleteSelected; //Deleta algo selecionado ou seja marcado na Lista

ou

ListBox1.Items.Delete(ListBox1.ItemIndex); //Deleta algo selecionado ou seja marcado na Lista

ListBox1.Items.Clear(); //Limpar tudo que contiver na Lista

ou

ListBox1.Clear; // Limpar tudo que contiver na Lista

———————————————————————————–

{ Abrir Item }

Código:
if OpenDialog1.Execute then //Executa o OpenDialog
ListBox1.Items.LoadFromFile(OpenDialog1.FileName); //Abre texto para Lista do destino selecionado

ou

ListBox1.Items.LoadFromFile('Lista de Texto'); //Caso houver alguma lista na pasta do prjeto com nome Lista de Texto abre o item para a Lista

———————————————————————————–

{ Salvar Item }

Código:
if SaveDialog1.Execute then //Executa o SaveDialog
ListBox1.Items.SaveToFile(SaveDialog1.FileName); //Salva texto da Lista com escolha de destino

ou

ListBox1.Items.SaveToFile('Lista de Texto'); //Salva item na mesma pasta do projeto sem a necessidade de escolher destino

———————————————————————————–

{ Adicionar }

Código:
ListBox1.Items.Add(Edit1.Text); //Adiciona o que estiver no Text do Edit para a Lista

Edit1.Text := ListBox1.Items.Strings[ListBox1.itemIndex]; //Adiciona no Edit o item slecionado na Lista ou marcado

Label1.Caption := ListBox1.Items.Strings[ListBox1.itemIndex]; //Adiciona na Label o item slecionado na Lista ou marcado

———————————————————————————–

{ Ir para o ultimo item da Lista }

Código:
ListBox1.TopIndex: = -1 + ListBox1.Items.Count;

———————————————————————————–

{ Mover items de posição no ListBox }

Antes de mais nada coloque como formulário de nível :

Código:
var
Form1: TForm1;
StartingPoint : TPoint;

Coloque no OnCreat do Form :

Código:
procedure TForm1.FormCreate(Sender: TObject);
begin
ListBox1.DragMode:= dmAutomatic;
end;

Coloque no OnDragDrop do ListBox :

Código:
procedure TForm1.ListBox1DragDrop(Sender, Source: TObject; X, Y: Integer);
var
DropPosition, StartPosition: Integer;
DropPoint: TPoint;
begin
DropPoint.X := X;
DropPoint.Y := Y;
with Source as TListBox do
begin
StartPosition := ItemAtPos(StartingPoint,True) ;
DropPosition := ItemAtPos(DropPoint,True) ;

Items.Move(StartPosition, DropPosition) ;
end ;
end;

Coloque no OnDragOver do Listbox :

Código:
procedure TForm1.ListBox1DragOver(Sender, Source: TObject; X, Y: Integer;
State: TDragState; var Accept: Boolean);
begin
Accept:= Source = ListBox1;
end;

E por fim coloque no OnMouseMove do ListBox :

Código:
procedure TForm1.ListBox1MouseMove(Sender: TObject; Shift: TShiftState; X,
Y: Integer);
begin
StartingPoint.X:= X;
StartingPoint.Y := Y;
end;

———————————————————————————–

{ Mostrar Hint de items do ListBox }

Coloque Listbox.ShowHint := true ;

Depois em OnMouseMove :

Código:
procedure TForm1.ListBox1MouseMove (Sender: TObject; Shift: TShiftState; X, Y: Integer) ;
var lstIndex : Integer ;
begin
with ListBox1 do
begin
lstIndex:=SendMessage(Handle, LB_ITEMFROMPOINT, 0, MakeLParam(x,y)) ;
if (lstIndex >= 0) and (lstIndex <= Items.Count) then
Hint := Items[lstIndex]
else
Hint := ''
end;
end;

———————————————————————————–

{ Pesquisa de texto no Listbox pelo Edit }

Coloque no OnChange do Edit :

Código:
procedure TForm1.Edit1Change(Sender: TObject);
const
indexStart = -1;
var
search : array[0..128] of Char;
begin
//make sure Length(Edit1.Text) <= 128
StrPCopy(search, Edit1.Text) ;
ListBox1.ItemIndex := ListBox1.Perform(LB_SELECTSTRING, indexStart, LongInt(@search)) ;
end;

———————————————————————————–

{ Remover multiplos Items selecionados de um ListBox }

Coloque ListBox1.MultiSelect = true ;

Depois coloque num button sei la :

Código:
var
ii : integer;
begin
with ListBox1 do
begin
for ii := -1 + Items.Count downto 0 do
if Selected[ii] then Items.Delete(ii) ;
end;
end;

———————————————————————————–

{ Ordenação da Listbox }

-> Descer um item selecionado :

Código:
var
NovoIndex : Integer;
begin
if not (lbx1.ItemIndex = lbx1.Items.Count-1) then
begin
NovoIndex := lbx1.ItemIndex + 1;
lbx1.Items.Move(lbx1.ItemIndex, NovoIndex);
lbx1.ItemIndex := NovoIndex;
lbx1.SetFocus;
end;
end;

-> Subir um item selecionado :

Código:
var
NovoIndex : Integer;
begin
if not (lbx1.ItemIndex - 1 < 0) then
begin
NovoIndex := lbx1.ItemIndex - 1;
lbx1.Items.Move(lbx1.ItemIndex, NovoIndex);
lbx1.ItemIndex := NovoIndex;
lbx1.SetFocus;
end;
end;

———————————————————————————–

{ Manipulação Simples}

Exemplo de como utilizar uma string para formatação…

Eu tenho como string “botecounix” e pretendo formatar até boteco,então faço o seguinte :

Código:
procedure TForm1.Button1Click(Sender: TObject);
var
X : Integer;
S1 : String;
S2 : String;
begin
for X := 0 to ListBox1.Items.Count-1 do
begin
S1 := Form1.ListBox1.Items[X];
S2 := 'unix'; //Edit1.Text
Delete(S1, Pos(S2, S1) , length( S2 ) );
Form1.ListBox1.Items[X] :=S1;
end;
end;

Obs: Caso estiver somente com a string sendo referencia inicial de linha o codigo não ira remove-la.