Using it in PowerShell

I created two PowerShell functions to mirror the Python ones Invoke-Translate  and New-TranslationTable.

The following example shows the usage of  Invoke-Translate. Here, every vowel in a string is replaced by its vowel position.

$InputTable = "aeiou"            
$OutputTable = "12345"            
$TranslationTable = New-TranslationTable $InputTable $OutputTable            
            
$string = "this is string example....wow!!!";            
            
Invoke-Translate $string $TranslationTable             
                      
th3s 3s str3ng 2x1mpl2....w4w!!!            

This example deletes all ‘x’ and ‘m’ characters from the string before doing the translate.

$InputTable = "aeiou"            
$OutputTable = "12345"            
$TranslationTable = New-TranslationTable $InputTable $OutputTable            
            
$string = "this is string example....wow!!!";            
            
Invoke-Translate $string $TranslationTable 'xm'             
            
th3s 3s str3ng 21pl2....w4w!!!

Grab the PowerShell Script

The PowerShell script is here on GitHub.

Have fun!

I am reading and reviewing NumPy 1.5 Beginner’s Guide. I like the examples the author presents and I figured I’d reproduce some using PowerShell.

PowerShell Code

Here is one: From a date range, display the second to last Friday.

I foreach over a range of numbers, starting with an initial date (in the Begin Block of the ForEach), adding a day each time through the loop (in the Process Block of the ForEach), picking out only the Friday dates with the Where cmdlet. This returns an array of dates, so I use array slicing to display the second to last element using [-2].

(1..31 |             
    ForEach {$date = Get-Date("11/30/11")} {            
        $date = $date.AddDays(1)            
        $date            
    } | Where {$_.DayOfWeek -eq "Friday"})[-2]            
            
# Prints            
Friday, December 23, 2011 12:00:00 AM

NumPy (from Numerical Python) is an open source Python library for scientific
computing. NumPy lets you work with arrays and matrices in a natural way.

I blogged about NumPy and SciPy for IronPython / #.Net. These libraries have be been optimized and provided custom .Net interfaces. This means that the full functionality is available to all .Net languages.

That means PowerShell, so I’m interested.

NumPy contains a long list of useful mathematical functions including some for linear algebra,
Fourier transformation, and random number generation routines. NumPy allows rapid interactive prototyping.

Here is a sample chapter from the book. Python has been around since the early 90’s and their open source libraries are very mature and can shortcut plenty of work.  That coupled with IronPython for .Net means a potentially seamless integration with PowerShell. NymPy is used by scientists, engineers, quantitative data analysts and more.

I am looking forward to learning more about how to use it and where it is applied.

One of Neal Ford’s slides captures the idea.

The Strategy Pattern

Formally speaking, the strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. Strategy lets the algorithm vary independently from clients that use it.

function ql {$args}            
            
function CalcByMult {            
    param($n,$m)             
            
    $n*$m            
}            
            
function CalcByManyAdds {            
    param($n,$m)            
                
    1..$n | % {$result = 0} { $result += $m } {$result}            
}            
            
            
$sampleData = @(            
    ,(3,4,12)            
    ,(5,-5,-25)            
)            
             
$strategies = ql CalcByMult CalcByManyAdds            
             
foreach($Dataset in $sampleData) {            
    foreach($strategy in $strategies) {            
        $Dataset[2] -eq (& $strategy $Dataset[0] $Dataset[1])            
    }            
}

Why Bother with Extra Structure?

Here I am creating an array of PowerShell script blocks for the strategies, eliminating the ceremony of naming them.

$sampleData = @(            
    ,(3,4,12)            
    ,(5,-5,-25)            
)            
             
$strategies =             
{param($n,$m) $n*$m},            
{            
    param($n,$m)            
    1..$n | % {$result = 0} { $result += $m } {$result}            
}            
             
foreach($Dataset in $sampleData) {            
    foreach($strategy in $strategies) {            
        $Dataset[2] -eq (& $strategy $Dataset[0] $Dataset[1])            
    }            
}

PowerShell lets me leverage .Net to do heavy lifting from the command-line

• 8 Minute Demo – .NET Scripting Object – PowerShell! – Opalis Software, a Toronto-based private company that is a leader in IT process automation software
• David Kennedy is a security ninja. He gave his PowerShell talk at Blackhat and Defcon. Here are the presentation and samples

This talk was about the powerful ability to perform advanced tasks through PowerShell and how you can utilize PowerShell on penetration tests.

• Splunk enables you to search, report, monitor and analyze streaming and historical data from any source across your entire IT infrastructure. Plus, a Splunk PowerShell snap-in.
• Reading XML in PowerShell, Python and Ruby, oh my! – interesting to see how to work with XML side by side in these languages

It’s not often that you get to spearhead the creation of a major new Microsoft API and it feels great to have seen this through from beginning to end

He works on distributed systems, data mining, programming languages, and software development tools. Before Google, Rob was a member of the Computing Sciences Research Center at Bell Labs, the lab that developed Unix. While there, he worked on computer graphics, user interfaces, languages, concurrent programming, and distributed systems. He was an architect of the Plan 9 and Inferno operating systems and is the co-author with Brian Kernighan of The Unix Programming Environment and The Practice of Programming.

• Google’s Go: A New Programming Language That’s Python Meets C++
• Google hopes to remake programming with Go

For many years there was no record type in the Python language […] Guido never considered that request […] "in real life you always need to add methods to your data, so just use a custom class"

In PowerShell you can create property bags two ways, Add-Member and Select-Object. Often you need a function that takes parameters and returns an object to hold some data.  Typing this out takes time, tweaking and testing.

Below, New-Function generates your function. This example creates a function named New-Pair that takes two parameters, item1 and item2.

Notice the next line uses the newly created function.

New-Function 'New-Pair' 'item1 item2'            
            
New-Pair 1 2 | Format-Table -AutoSize

Another Example

New-Function creates a PowerShell function so parameter binding works too.

New-Function `
  'New-Person' 'FirstName LastName Address City State Zip'            
            
New-Person John Doe -Zip 10001

The Factory

Function New-Function ($name, $properties) {            
    $parts = $properties.trim().split(' ')            
    $parts |            
        %{            
            $selectProperties += @" 
 @{
            Name = '$_'
            Expression = {`$$_}
        },
"@            
        }            
            
# simple way to remove the trailing comma                    
$selectProperties = $selectProperties -Replace ",$", ""            
            
Invoke-Expression @"
Function Global:$name {
param(`$$($parts -join ',$'))
    
New-Object PSObject | 
    select $selectProperties
}        
"@            
}

Grab The Code

Toby Segaran’s new book takes you into the world of machine learning and statistics and explains how to draw conclusions about user experience, marketing, personal tastes and human behavior.

Toby presents how to use these algorithms to mine sites like Facebook, MovieLens, Delicious, Blogs and more.

Also covered:

• Support-vector machines
• Evolving intelligence algorithms
• Optimization algorithms

The book is a great way to dive deeper into PowerShell (or any language), Python and data mining.

C# 3.5 version

HERE

PowerShell Tanimoto

param(
  $q=("shirts","socks","pants","shoes"),
  $t=("skirts","socks","shoes")
)

$c = $q | where {$t -eq $_}
$c.count / ($q.count + $t.count - $c.count)

Python Tanimoto

def tanimoto(a,b):
  c=[v for v in a if v in b]
  return float(len(c))/(len(a)+len(b)-len(c))