humming bird

インタラクティブなコンソール - GAE

noreply@blogger.com (y@s) — Sun, 23 May 2010 15:30:00 +0000

インタラクティブなコンソールで紹介されている「appengine_console.py」を今現在使えるように書き換えました。

事前準備として、app.yamlに以下を追加。

handlers:
    - url: /remote_api
      script: $PYTHON_LIB/google/appengine/ext/remote_api/handler.py
      login: admin

#appengine_console.py
import os, sys, code, getpass

# append path
#C:\\google_appengine
#C:\\google_appengine\lib\webob
#C:\\google_appengine\lib\django
#C:\\google_appengine\lib\yaml\lib
gae_path = 'C:\\google_appengine'
sys.path = [gae_path,
            os.path.join(gae_path,'lib','webob'),
            os.path.join(gae_path,'lib','django'),
            os.path.join(gae_path,'lib','yaml','lib')] + sys.path

from google.appengine.ext            import db
from google.appengine.ext.remote_api import remote_api_stub

def auth_func():
    return raw_input('Username:'), getpass.getpass('Password:')

if len(sys.argv) < 2:
    print 'Usage: %s app_id [host]' % (sys.argv[0],)
else:
    arg2 = len(sys.argv) > 2 and sys.argv[2]
    app_id = sys.argv[1]
    host = 'localhost:8080' if arg2 else '%s.appspot.com' % app_id

    remote_api_stub.ConfigureRemoteDatastore(app_id, '/remote_api', auth_func, host)
    code.interact('App Engine interactive console for %s%s' % (app_id,' @local' if arg2 else ''), None, locals())

本番データストアにアクセスできるだけでなく、ホストをローカルに設定すれば、当然ローカルのサーバーにもアクセスできるようになるだろうと思い試したらできたので、第3引数にTrueと評価される値を渡してやれば、ローカルサーバーにアクセスするよう修正した。

gae_path、ポート番号は適宜置き換えて下さい。

Usage

python appengine_console.py app_id [host]

[host]に何も渡さなければ本番サーバーに、Trueを渡すとローカルサーバーにアクセスすることになる。

remote_apiオモシロイ。
でもその話はまた気が向いたら。

Entityの削除について - GAE

noreply@blogger.com (y@s) — Sat, 22 May 2010 15:50:00 +0000

まず、以下のようなデータモデルあるとして、

class Foo(db.Model):
    index = db.IntegerProperty()

Entityを取得する

Model.all()を使用してEntityを取得する。

query = Foo.all()

Model.all()によって返される値はQueryオブジェクト。

こんな風に取得しても良い。

query = db.GqlQuery('SELECT * FROM Foo')
#   or
query = db.GqlQuery('SELECT __key__ FROM Foo')

db.GqlQuery()によって返される値はGqlQueryオブジェクト(のインスタンス)。

「Entityを削除する」という目的の上ではどちらでも構わない。

Entityを削除する

上記のような操作によって取得したGqlQueryオブジェクト、またはQueryオブジェクトのEntityの数が一つであれば、

db.delete(query)

このようにしても問題なくEntityを削除できる。

しかし、取得したEntityが複数である場合は例外が発生する

BadArgumentError: Expected only one model or key

複数のEntityを一度に削除する

deleteメソッドの引数は以下。

引用:関数 - Google App Engine - Google Code
削除するモデルインスタンス、エンティティの Key、エンティティのモデルインスタンスまたはキーのリスト。

つまり、複数のEntityを一度に削除するにはModelインスタンスのリストにしてからdeleteメソッドに渡す必要がある。

Modelインスタンスのリストにするにはfetchメソッドを使用する。

query.fetch(limit)

fetchの戻り値は「Modelインスタンス or 空」のリスト

その後、db.delete()で削除すれば良い。

db.delete(model_list)

まとめるとこんな流れになる。

query = Foo.all()
m_list = query.fetch(100)
db.delete(m_list)

Entityの数が多い、または削除したいModelの種類が複数なら、以下のようなメソッドを用意する。

def clear_data(model):
    try:
        q = model.all()
        while q.count():
            m = q.fetch(100)
            db.delete(m)
            q = model.all()
    except:
        return

tryで囲む必要はないかも。

使い方。

clear_data(Foo)

違う書き方をするならこんな感じかな。

def clear_data(model):
    s = 'SELECT * FROM %s' % model.entity_type()
    q = db.GqlQuery(s).fetch(100)
    while len(q):
        db.delete(q)
        q = db.GqlQuery(s).fetch(100)

jQueryでムリクリ文字列を扱う

noreply@blogger.com (y@s) — Wed, 12 May 2010 15:05:00 +0000

jQueryで配列や簡単なオブジェクトが扱えることが分かったので、それなら文字列も扱ってやろうじゃないか、という安易な発想で。

例えば、

$("foo")

とすると、この"foo"はドコに格納されるのか？というと、selectorプロパティに格納されている。

alert( $("foo").selector );

これで"foo"と表示される。

なので、こんなメソッドにしてみる。

jQuery.fn.alert = function(){
    alert(this.selector);
    return this;
}

$("foo").alert();//foo

難点はメソッドチェーンが行えないこと。上記のようにメソッド内で完結すれば良いのだが、値を返さなければ意味がない。
処理を行い、その都度selectorから文字列を取得する方法も考えられるがあまり現実的ではない気がする。
そもそも今やっていることが現実的ではないか... (^_^;)

そんなことを思いつつも

padLeftメソッド追加する

jQuery.extend(jQuery.fn,{
    times: function( n ){
        var ret = "", s = this.selector;
        for ( n *= 1 ; n > 0 ; n >>>= 1, s += s ) {
            if (n & 1) 
                ret += s;
        }
        return ret;

        //easy, but a little slow.
        //return new Array(+n + 1).join(this.selector);
    },
    padLeft: function(totalWidth, paddingChar){
        var s = this.selector, len  = totalWidth - s.length;
        return ( len < 1 ? "" : jQuery(paddingChar).times(len).slice(0, len) ) + s;
    }
});

Usage

var s = $("123").padLeft(6,"0");
//s -> 000123

要素がDom Nodeに追加されているかを確認する

noreply@blogger.com (y@s) — Wed, 12 May 2010 11:00:00 +0000

要素がDomノードに追加されているかを調べる。

例えば、まだDomノードに追加されていない要素の高さや幅を取得しようとしても0が返ってくる。
これではまずいこともあるだろう。

ということで、こんな関数を書いてみる。

function isAddedToDom(elm){
    while (elm.parentNode && elm.parentNode.tagName) {
        elm = elm.parentNode;
    }
    return elm.tagName.toLowerCase() === "html";
}

tagNameまで見ている理由

fragmentでループから抜ける
Document(elm.ownerDocument)にまで到達しないようにする

親要素がfragmentであれば、まだその要素はDomに追加されていないということなので、その時点でループから抜ける。

また、このwhileループはほっとくと ownerDocumentにまで到達してしまう場合がある。
ownerDocumentはDomに追加されていない要素でも同様に取得できてしまう。
そこでtagNameを見ることによってownerDocumentまで到達しないようにする。

この関数をjQueryで使う

$.extend($.expr[':'],{
    addedToDom: function (elm){
        //tagNameを見る理由
        // - fragmentで抜ける
        // - Document(elm.ownerDocument)にまで到達しないようにする
        while (elm.parentNode && elm.parentNode.tagName) {
            elm = elm.parentNode;
        }
        return elm.tagName.toLowerCase() === "html";
    }
});

Usage

isを使う

function foo( elm ){
    if ($(elm).is(":addedToDom")) {
        //something...
    }
}

filterを使う

var elm = $("foo").filter(":addedToDom");

正規表現のパターンチェッカーをリニューアル - ЯegExpR

noreply@blogger.com (y@s) — Thu, 06 May 2010 15:05:00 +0000

JavaScriptの正規表現のパターンチェッカーをリニューアル!!
今回でVersion 3。
新しい機能も追加して、アドレスも変更。
名前も新たに「ЯegExpR」として公開。

ЯegExpR

因みに以前のバージョンはこれ。

新機能:profiler

何がしたいか、一度使ってもらえれば理解できると思うが、正規表現パターンを分解して理解しやすい形にしようと試みた。
正規表現はパターンが長くなると何やってるか理解するのに苦労するからね。

正直、見切り発車な部分はあるが、完成すれば結構便利な機能じゃないかな？

今回の無駄なこだわりは全く画像を使用していないトコロ。
だから、IEなんかだと見た目がしょぼいのであしからず。

jQueryメソッドにトリガーを仕込む

noreply@blogger.com (y@s) — Sun, 25 Apr 2010 14:00:00 +0000

domに追加される前に要素のフォントサイズを取得しようとしてもIEではできない。
それなら要素に追加されたタイミングで取得すれば良いんじゃないかな、と。

appendにトリガーを仕込む。

var foo = $("<p>").addClass("foo");

var wrap = $("#foo-wrap")
    .bind("appended", function(e, args){
        args.text(args.css("font-size"));
    });

var _append = wrap.append;

wrap.append = function(){
    alert(arguments[0].css("font-size"));//IE -> undefined
    _append.apply(this, arguments);
    this.trigger("appended", arguments);
}

wrap.append(foo);

foo要素自身のフォントサイズが表示される。

本当ならfoo要素に何らかの処理を施すことで実現することが最善な方法と思われるが、それが可能なら苦労はしないのだよ。(-。-)y-゜゜゜

汎用的だが、現実的じゃない方法も一つ。

var _append = jQuery.fn.append;

jQuery.fn.append = function(){
    _append.apply(this, arguments);

    $(arguments).each(function(){
        if($(this).is(".foo")){
            $(document).trigger("foo-appended", this);
        }
    });
}

$(document).bind("foo-appended",function(e, foo){
    $(foo).css("color","#f00");
});


var a = $("<p>");
    b = a.clone().addClass("foo");

a.text("another");
b.text("foo")

$(document.body).append(a,b);

fooクラスの属性を持つ要素の文字色を赤色にしている。

ムチャするわ~ (^_^;)

jQueryのことが少しわかった気がする

noreply@blogger.com (y@s) — Fri, 23 Apr 2010 15:40:00 +0000

「あ、そうか!」みたいな感覚。
jQueryというより、Javascriptを(少しだけ)理解できたと言った方が良いかな?

常に型を意識して引数や戻り値を扱う言語出身故に、気付くのが遅かったのかもしれない。

振りかえると、私はjQueryオブジェクトとそれ以外のオブジェクトを全く別モノとして捉えていたことが結果として、Javascriptという言語の柔軟性を失わせていたように思う。

jQueryの最も重要である「$()」がナニモノか?　を探りたい。

まずは配列を渡してみる。

function say(){
    console.log("hello");
}

$([say, say]).each(function(i,item){
    item();
});
//output:
//hello
//hello

つまり、このように同じことをしているだけ。

var ary = [1, 2, 3];

$(ary).each(function(i,item){
    console.log( item );
});
//output:
//1
//2
//3

$.each(ary, function(i,item){
    console.log( item );
});
//output:
//1
//2
//3

逆にjQueryオブジェクトを渡してみる。

var p = $("<p>").text("foo");
$.each(p, function(i,item){
    console.log( $(item).text() );
});
//output:
//foo

jQueryではeachメソッドにオブジェクトを渡すと配列を扱うような動作をする。

var o = {a:"foo", b: "bar"};

$.each(o, function(i,item){
    console.log( item );
});
//output:
//foo
//bar

いろいろ試してみる。

var o = {a:"foo", b: "bar"};
    
$([o, o]).each(function(i,item){
    console.log( item.a );
});
//output:
//foo
//foo

$(o).each(function(i,item){
    console.log( item.a );
    console.log( item.b );
});
//output:
//foo
//bar

$(o).add(o).each(function(i,item){
    console.log( item.a );
    console.log( item.b );
});
//output:
//foo
//bar
//foo
//bar

少し無茶なことをしてみる。

ret = $([1, 2, 3, 4]).filter(function(){
    return this % 2 === 0;
});
//ret -> [2, 4]

ret = $([0, 1, 99, 3]).index(99);
//ret -> 2

filterメソッドの戻り値はjQueryオブジェクトだが、その中身は普通に扱える。

最後に、animateメソッドでopacity値を変化させる。

$("<div>")
    .css({opacity: 0})
    .animate({opacity: 1}, {
        duration: 500,
        step    : function(){
            console.log($(this).css("opacity"));
        }
    });

これを応用して、value値を変化させる。

$({value: 0}).animate({value: 100}, {
    duration: 500,
    step    : function(){
        console.log(this.value);
    }
});

何やらおかしなことをしているように見えるかも知れないが、jQuery.fx.cur辺りを見ると理解できると思う。

私もココで初めてこのような処理を見たときには何でこうなるのか正直理解できなかった。

しかし、閃きと言うか、気付いたと言うべきか、$() にdom要素ではないナニモノかを渡して何らかの処理を行うことも可能であることに最近ようやく気付くことができた。

C# - 拡張メソッドでIsUniq

noreply@blogger.com (y@s) — Thu, 22 Apr 2010 16:00:00 +0000

拡張メソッドで遊んでみた。
配列内の全ての値がユニークであるかを調べるメソッド「IsUniq」だすぅ。

code-1

//loop 1E6 -> 176ms
public static bool IsUniq<T>(this T[] source)
{
    for (int i = 0; i < source.Length - 1; i++)
    {
        if (Array.IndexOf(source, source[i], i + 1) != -1)
        {
            return false;
        }
    }

    return true;
}

code-2

//非破壊的ソート
public static T[] Sort<T>(this T[] source)
{
    T[] clone = (T[])source.Clone();
    Array.Sort(clone);
    return clone;
}

//loop 1E6 -> 455ms
public static bool IsUniq<T>(this T[] source)
{
    T[] clone = source.Sort();
    for (int i = 0, j = clone.Length - 1; i < j; i++)
    {
        if (clone[i].Equals(clone[i + 1]))
        {
            return false;
        }
    }

    return true;
}

非破壊的ソートメソッドを書き足したのだが、そのせい(?)でパフォーマンスが今一つ。

code-3

//loop 1E6 -> 2050ms
public static bool IsUniq<T>(this T[] source)
{
    for (int i = 0; i < source.Length - 1; i++)
    {
        T tmp = source[i];

        if (source.Skip(i + 1).ToArray().Any((item) => tmp.Equals(item)))
        {
            return false;
        }
    }

    return true;
}

Linqを使ってコードを少々シンプルにした。
やろうとしていることは「code - 1」に近いかな?
パフォーマンス的に論外。

code-4

//loop 1E6 -> 145ms
public static bool IsUniq<T>(this T[] source, Func<T, T, bool> comparer)
{
    int length = source.Length;

    for (int i = 0, j = length - 1; i < j; i++)
    {
        T currentItem = source[i];
        for (int n = i + 1; n < length; n++)
        {
            if (comparer(currentItem, source[n]))
            {
                return false;
            }
        }
    }

    return true;
}

これが一番パフォーマンスが良い結果になった。

Usage

int[] arr = { 12, 34, 56, 78, 90};
bool ret = arr.IsUniq();
//or
//bool ret = arr.IsUniq((x, y) => x == y);

ここからは御ふざけで御座います。

Distinctを使う。

//loop 1E6 -> 787ms
public static bool IsUniq<T>(this T[] source)
{
    return source.Length == ((T[])source.Clone()).Distinct().Count();
}

やはり、配列コピーしたりLinqメソッド使うと重くなるよね。

Whereを使う。

//loop 1E6 -> 1615ms
public static bool IsUniq<T>(this T[] source)
{
    for (int i = 0; i < source.Length - 1; i++)
    {
        T tmp = source[i];

        if (source.Skip(i + 1).Where((item) => tmp.Equals(item)).Count() > 0)
        {
            return false;
        }
    }

    return true;
}

お話になりません。

Allを使う

//loop 1E6 -> 1380ms
public static bool IsUniq<T>(this T[] source)
{
    for (int i = 0; i < source.Length - 1; i++)
    {
        T tmp = source[i];

        if (!source.Skip(i + 1).All((item) => !tmp.Equals(item)))
        {
            return false;
        }
    }

    return true;
}

...飽きた。

ブログ進化論

noreply@blogger.com (y@s) — Wed, 21 Apr 2010 22:30:00 +0000

これまでWebサイト(Webアプリケーション)はローカルで使用するアプリケーションを真似たインターフェイスにしようと努力されてきたように感じる。

それと同じように、これからのWebにおける情報は電子書籍チックになっていくのではないだろうか。
iPadが普及し、電子書籍化が進むのに並行して、ブログというものの形も変わるはず。
「ブログ」と言うより、「個人が情報を公開する手段」と言い換えた方が適切かもしれないが敢えて。

「書籍を出版するかのようにWebに公開する個人サイト」

例えば小説のような物語の続きを更新していくブログや、雑誌のように様々な情報を日々アップしていくブログはこれまでにもあっただろう。

だが、これからは上から下ではなく、本のページを捲るような感覚で閲覧、最新号を発行するかのような更新、欲しいモノがあればそれをクリックすると販売しているサイトへ移動、そして読者の感想がリアルタイムに更新される。

まるで出版物を制作するかのような感覚で、サイトを創り上げていく。
また、それらをCVSなどでリポジトリ管理できたら尚良いだろう。
そんな個人サイトを公開できるサービスが出てきてほしい。

誤字の修正などに迅速に対応可能、何より経費が掛らず誰でも公開できるというWebのメリットは大きい。
そのような場所で何らかを公開したいと思うユーザーは少なくないのでは(主観)。

私がこのようなサービスを期待する理由の一つとして、書籍のような段組みを可能とするHTML5の存在がある。これにCSS3とJavascriptを組み合わせれば、多くの表現の自由が与えられる。
さらに個人的にもう一つ付け加えるならIEが死んでくれると尚良いのだが...

つまるところ、Webの進化がまた新しいサービスを生み出していく、というだけの話。

すでに電子書籍を作成する会社が存在するご時世。Webサイトの作成にもこの波が必ず影響していくはず。それは公開する「モノ」によっては大きな波となるのではないだろうか。

私がどんなモノを想像しているのか、伝わりにくいだろうことは理解した上で書き綴ったのだが、暇と気力があったらApp Engineでも使って擬似的に私が想像するサイト(サービスは無理)を作れたら、と思う。

タグにマッチさせる正規表現

noreply@blogger.com (y@s) — Mon, 12 Apr 2010 13:20:00 +0000

HTMLタグ文字列にマッチさせる正規表現を書いてみた。

//html
var rtag = /<\w+(?:\s+\w+(?:\s*=\s*(?:".*?"|'.*?'|[^'">\s]+))?)?(?:\s?\/)?>|<\/\w+>/g;

//(x)html
var rxtag = /<\w+(?::\w+)?(?:\s+\w+(?:\s*=\s*(?:".*?"|'.*?'|[^'">\s]+))?)?(?:\s?\/)?>|<\/\w+(?::\w+)?>/g;

何かこんなに書かなくても良いように思う。(-_-;)

とりあえず、簡単にテスト。

var tagStr = [
    "<br/>",
    "<br />",
    "<p>abc<br>abc<br>abc</p>",
    "<h1></h1>",
    '<div style="vertical-align:bottom;"><span>foo</span></div>',
    "<img src='http://www.example.com' alt='&'/>",
    "<script type='text/javascript'><" + "/script>",
    "<p>１２３ABCあいうえお</p>",
    "abc<span>def\t\u3000\nghi</span>jklm",
    "<input type='text' value='A > B' />",
    "<style type='text/css'>\nbody{\n\tfont-family:'メイリオ',Meiryo;\n}\n</style>",
    "<gd:name value='foo'/>"
];

for ( var i = 0; i < tagStr.length ; i++ ) {
    //bug?回避のため毎回newする。
    var rgx = new RegExp(rtag);
    console.log( tagStr[i].match(rgx) );
}

コンソール:結果

["<br/>"]
["<br />"]
["<p>", "<br>", "<br>", "</p>"]
["<h1>", "</h1>"]
["<div style="vertical-align:bottom;">", "<span>", "</span>", "</div>"]
["<img src='http://www.example.com' alt='&'/>"]
["<script type='text/javascript'>", "</script>"]
["<p>", "</p>"]
["<span>", "</span>"]
["<input type='text' value='A > B' />"]
["<style type='text/css'>", "</style>"]
["<gd:name value='foo'/>"] //(x)html

最後のタグ文字列だけは(x)htmlバージョンの正規表現にのみマッチします。

もうちょっと簡単にする

//html
var rtag = /<\w+(?:\s+[^>]+)?\/?>|<\/\w+>/g;

//(x)html
var rxtag = /<\w+(?::\w+)?(?:\s+[^>]+)?\/?>|<\/\w+(?::\w+)?>/g;

HTMLに">"と書かずに">"とか書いてもちゃんと表示されちゃうワケだが、この簡易版の正規表現では許容できない。
というか、それを許すようなパターンを書こうとすると私ごときでは上記のようにパターンが長くなりすぎる。

なので、7行目の結果はこうなる。

["<input type='text' value='A >"]

が、これはそうなることが予想されていることなのでヨシとする。

まあ、ちゃんと">"と書けよ、と。

とりあえずこれでOK?

jQueryにこんなのがあった。

// Match a standalone tag
rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/

これはシングルタグにマッチさせるパターンなのだが"\1"とか使ってなかなか秀逸とか思ったが、これが"<p>"なんかにもマッチしちゃうので、使い方を工夫しないとこのままでは使えない。

空白文字が2種類あるから混乱するのだよ(全角空白じゃないよ)

noreply@blogger.com (y@s) — Fri, 02 Apr 2010 00:30:00 +0000

空白文字が2種類あることを知らなかったんですよね(^_^;)

まず、空白文字についての話の前に、知っておくべきことから。

Javascriptで"a"という文字を表現する方法。

alert("a");//a
alert("\x61");//a
alert("\u0061");//a

これを比較してみる。

alert("\x61" == "a");//true
alert("\x61" == "\u0061");//true
alert("\u0061" == "a");//true

正規表現ではどうだろう?

var ret
ret = /\u0061/.test("\x61");//true
ret = /\u0061/.test("a");//true
ret = /a/.test("\x61");//true
ret = /a/.test("\u0061");//true
ret = /\x61/.test("a");//true
ret = /\x61/.test("\u0061");//true

ワタクシ的にはこれを知ったぐらい仰け反った(・Д・;)

"12" + 3 //-> "123"
"12" - 3 //-> 9

本題へ

「マジメに正規表現パターンを書こう!!」
↓
「正規表現で「\s」は何にマッチするのか?」

というのが発端。

" "(半角空白)は"\x20"に等しい。

" " == "\x20" //true
/\s/.test(" ") //true
/\s/.test("\x20") //true

ここでjQueryで使われている正規表現を思い出した。

rtrim = /^(\s|\u00A0)+|(\s|\u00A0)+$/g;

「\u00A0」って何だ?
調べるとやはりこれは空白文字だった。

つまり、文字コード32(0x20)と160(0xA0)の二つが空白文字だった。

文字コードが違うので当然この二つは同じ文字ではない。

"\x20" == "\xA0"　//false

で、正規表現の「\s」がこの二つにマッチすれば良いのだが、IEでは"\xA0"にマッチしてくれない。
ということでjQueryではあのような正規表現となっていることが理解できた。

全角空白文字は?

全角空白もIEではマッチしない。
なので、正しいトリムの正規表現はこうなる。

rtrim = /^(\s|\u00A0|\u3000)+|(\s|\u00A0|\u3000)+$/g;

しかし、私的にはこうした方が良いように思う。

rtrim = /^[\s\u00A0\u3000]+|[\s\u00A0\u3000]+$/g;

トリム関数の動作についての解釈の違いかな?

さらに

もう少し調べてみると、

引用:Regular Expressions - MDC
...ホワイトスペース以外の 1 文字にマッチする。[^ \f\n\r\t\v\u00A0\u2028\u2029] と同等。...

ということで

rtrim = /^[\f\n\r\t\v\u0020\u00a0\u2028\u2029\u3000]+|[\f\n\r\t\v\u0020\u00a0\u2028\u2029\u3000]+$/g;

となり、

さらに

引用:RegExp - MDC
1. 註: equivalent_s

これは以下の表現と同等です。：
[\t\n\v\f\r \u00a0\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u2028\u2029\u3000]

ということで最終的にこうなった。

rtrim = /^[\f\n\r\t\v\u0020\u00a0\u2000-\u200b\u2028-\u3000]+|[\f\n\r\t\v\u0020\u00a0\u2000-\u200b\u2028-\u3000]+$/g;

たかが空白文字を取り除くのに長すぎ(-_-;)

Bloggerの新しいテンプレートの設定について

noreply@blogger.com (y@s) — Tue, 30 Mar 2010 22:00:00 +0000

正直な話し、まだ2,3度ほどしか触っていないので、もっと調べれば他にも色々出てくるかもしれないが、とりあえずBloggerユーザーのハシクレとして、何かのお役に立てればこれ幸い。

今回はテンプレートを眺めていて気付いたこと。

このテンプレートをイジるにはVariableタグ(<Variable/>)を詳しく追ってみる必要がありそうだ。

Groupタグ

VariableタグにはGroupタグ(<Group/>)に囲まれたモノとそうでないものがある。

Groupタグに囲まれた場合、Groupタグのselector属性(selector='.post'など)の値によって取得される要素に変更が加えられるということになる。
例えば、selectorの値が".post"なら"post"というクラスを持つ要素に対して、子要素に持つVariableタグの値をそれぞれ適用します、ということになる。

Variableタグ

name
固有の変数名と捉えれば良いでしょう。

description
テンプレートデザイナーの[アドバンス]で表示される文字と関係している。
Groupタグの場合、"Backgrounds"なら"背景"と表示され、その文字をクリックするとその横に表示される設定項目のタイトルに子要素のdescription属性の値がそれぞれ表示されるようになっています。

例えば、

"Outer Background"なら"外側の背景"
"Header Background"なら"ヘッダーの背景"
"Post Background"は"投稿の背景"

というように。

ある程度の定形語ならクライアントの言語、つまり日本語に変換されて表示されるようになっている。
ここに適当な言葉を入れても、単にそのまま表示されるだけなので、すべて日本語にしてしまっても自分で使用する分には何の問題もありません。

default
テンプレートデザイナーで「...デフォルトにリセット」を行うと現在の設定がこの値に戻されます。

type
値の種類、型のようなものですね。

value
実際に適用される値がこれになります。
中には「$(widget.title.text.color)」というような、「$()」で囲まれた文字がありますが、これを例にするとVariableタグのname属性が"widget.title.text.color"の値を参照していることになります。
つまり"widget.title.text.color"と同じ値を設定します、ということですね。

もし、この"widget.title.text.color"というname属性のVariableタグが無かったらどうなるか?
まず、defaultの値を参照します。
それでも無い場合はテンプレートの保存時に警告が出る仕様になっています。
例えば、「default="$(foo)" value="$(bar)"」みたいなことになっていてVariableタグのいずれにも「name="foo"」や「name="bar"」が無かったらテンプレートの保存時に警告するということです。

こんなのプログラマの類でないと分かりづらいですよね。
そういう私はもののけの類ですが...

これで、Variableタグを独自に追加したり、CSSをイジるのが容易になるのではないでしょうか。

余談:
firefoxでテンプレートデザイナーが表示できないのって私だけですか?(^_^;)

javascript で.Net形式のDate フォーマットに変換する

noreply@blogger.com (y@s) — Tue, 23 Mar 2010 15:30:00 +0000

私を含め、.NET Frameworkに慣れた人がJavascriptで容易に日付を取得できるよう、DateオブジェクトのtoStringを.NET FrameworkのDateTimeに合わせた動作を実装する。

標準の日時書式指定文字列を参考にしました。

Usage

定型書式

var date = new Date("2010/03/24");
alert(date.toString("D"));
//=> 2010年3月24日

現在"O"、"o"、"U"には対応していません。今後対応するかも未定です。

定型書式 + 言語指定
.Netの場合、CultureInfoを引数に渡すとそのカルチャに合わせた結果を返すのでこれを実装してみた。

alert(date.toString("D","en"));
//=> Wednesday, March 24, 2010

カスタム書式

alert(date.toString("yyyy/MM/dd"));
//=> 2010/03/24

Demo:dateFormat.html

Source:dateFormat.js

備考
Date.prototype.toStringに関しては渡された引数がどのパターンにも一致しなければデフォルトの処理を行うようにしてあるので問題は無いと思われる。

今後
今回サポートした言語は「en」と「ja」の二つだが、できればどの言語にも容易に対応できるような実装に変更したい。
それを行った上で、「en」と「ja」を二つのファイルに分割し、ファイルを小さくしたい。

追記
2010-04-12:
f,Fについての解釈の間違いによる不具合を修正。

Convertを使わずに2進数、10進数の相互変換を行う - C#

noreply@blogger.com (y@s) — Tue, 09 Mar 2010 09:00:00 +0000

通常ならこのような変換にはSystem.Convertを使うだろうが、これを使わずに変換を行う処理を自身で書いてみたくなった。

.NET Frameworkに勝るモノを自身で書ける、などとは思わないが、デモンストレーション的な感じでね。

10進数 → 2進数

例えば、10進数から2進数への変換は以下のように行う。

string bin = Convert.ToString(22, 2);//10110

これを自身で実装してみる。
色々書いてみたが、結局ビット演算を使うのが一番速いし、コードもシンプルになる。

Example

/// <summary>
/// 10進数を2進数文字列に変換します。
/// </summary>
/// <param name="dec">10進数</param>
/// <returns>2進数文字列</returns>
static string DecimalToBinaryString(long dec)
{
    string ret = string.Empty;

    for (; dec > 0; dec >>= 1)
    {
        ret = (dec & 1) + ret;
    }

    return ret;
}

dec & 1で右端のビットのみを取得している。
右端のビットを取得したら変数dec右へビットシフトする。
変数decを追っていくと以下のようになる。

//引数:22
dec: 22(10110)
dec: 11(01011)
dec:  5(00101)
dec:  2(00010)
dec:  1(00001)
dec:  0(00000)

このようにしてビットを一つづつ取得して文字列にしている。

処理速度は？というとConvertクラスと比較して約8倍掛る結果となった。

ん~...　使えね~(^_^;)

2進数 → 10進数

Convertクラスを使用して2進数文字列から10進数への変換は以下のように行う。

long dec = Convert.ToInt64("10110", 2);//22

これを実装してみる。
Example

/// <summary>
/// 2進数文字列を10進数(long)に変換します。
/// </summary>
/// <param name="bin">2進数文字列</param>
/// <returns>10進数</returns>
static long BinaryToDecimalNumber(string bin)
{
    long ret = 0;

    foreach (var chr in bin)
    {
        ret = (ret << 1) | ((long)chr & 1);
    }

    return ret;
}

文字を一つづつ取り出して足していくのですが、ここでもビット演算が処理を簡単にしてくれる。

コード内の「(long)chr & 1」を説明すると、string型から文字を一つづつchar型として取りだしたモノがchrになりますが、これを数値型(long)にキャストし、そして右端のビットのみを取得しています。

Type:Char 0 = Ascii:48　binay:110000
Type:Char 1 = Ascii:49　binay:110001

コード内の「ret << 1」は先程説明した値chrを常に右側のビットとして足していくので、既存の値を左へシフトして一番右側のビットを開けてやっているワケです。

処理の過程を表すと以下のようになる。

//引数:"10110"
 0(00000) + 1 =  1(00001)
 2(00010) + 0 =  2(00010)
 4(00100) + 1 =  5(00101)
10(01010) + 1 = 11(01011)
22(10110) + 0 = 22(10110)

これをConvertクラスを使用した場合の処理速度と比較してみる。

1000 * 1000回処理を行う際に掛った時間

//引数:"10110"(22)
Convert.ToInt32       : 112ms
Convert.ToInt64       : 174ms
BinaryToDecimalNumber :  80ms

何故か私が書いたモノのが一番速かったのだが、私の書いたモノには欠点がある。
それは1以上の値しか扱えないこと。つまり「0」もダメ。
しかしConvertクラスなら負の数も扱えるのでこちらの方が優秀。
扱う値の範囲が分かっているなら、私の書いたモノを使っても問題ない場合もあるだろうが、やはりConvertクラスを使う方が無難ですよね。

一つの発見はToInt32とToInt64では処理速度に差がある、ということでした。

初期値 != 既定値???

noreply@blogger.com (y@s) — Wed, 03 Mar 2010 22:30:00 +0000

初期値と既定値は同じだと勝手に思い込んでいた。

しかし、違うのねん!! というお話し。

初期値と既定値、そしてそれに関連して初期化が絡み、私の頭の中で適当に解釈されていたこれらを整理したい。

「C# 初期値」と検索すると何故か二番目に表示されるのが既定値の一覧表 (C# リファレンス)

読んで字のごとく、既定値の一覧だ。
だが、初期値と既定値は必ずしも一致しない。

例えば、こんなクラスがあったとする。

class Hoge
{
    public int IntValue { get; set; }
}

このHogeクラスのインスタンスを生成すると、IntValueにはint型の既定値である「0」が入る。

つまり、初期化を明示的に行っていないIntValueプロパティの初期値はその型の既定値となるワケだ。

では、IntValueプロパティの初期化を行う。
初期値を1とする。

パターン1:

class Hoge1
{
    public Hoge1()
    {
        this.IntValue = 1;
    }

    public int IntValue { get; set; }
}

パターン2:

class Hoge2
{
    private int intValue;

    public Hoge2()
    {
        intValue = 1;
    }

    public int IntValue
    {
        get
        {
            return intValue;
        }
        set
        {
            intValue = value;
        }
    }
}

パターン3:

class Hoge3
{
    private int intValue = 1;

    public int IntValue
    {
        get
        {
            return intValue;
        }
        set
        {
            intValue = value;
        }
    }
}

分かりやすいようにint型の既定値「0」ではない値「1」を設定した。

どれもやっていることに大差はない。
ここで重要なのは初期値を設定したことにある。
最初に何らかの値を設定することを初期化と言い、初期化によって設定された値が初期値である。

何だか当り前のことを書いてて若干アホらしくなってきた...

初期値と既定値が同じ値となる可能性もあるが、初期値と既定値が同じ場合の初期化の必要性をここで四の五の言うつもりはないのでそれに関してはスルー。

「何で私が混乱してしまったのか?」を最初に説明すべきだったかも知れないが、今更に述べるが、DefaultValueAttributeが何モノなのか?分からなくなってしまったから。
説明には「プロパティの既定値を指定します。」とある。

私は勝手に「これを使えば初期化しなくてもその値が設定される？」と思ったのだが、どうやらそういうことではないようだ。

例えば、こんなクラスがあったとする。

class Foo
{
    public Foo()
    {
        //this.IntValue = 100;
        //this.BoolValue = true;
        //this.ColorValue = Color.White;
    }

    [DefaultValue(typeof(int), "100")]
    public int IntValue { get; set; }

    [DefaultValue(typeof(bool), "True")]
    public bool BoolValue { get; set; }

    [DefaultValue(typeof(Color), "White")]
    public Color ColorValue { get; set; }
}

このFooクラスのインスタンスを生成しても、そのプロパティの値はそれぞれの型の既定値のままだった。

ん~~　(-。-;)y-゜゜゜

やはり初期化しないとダメなのか？

引用:解説
任意の値を指定してDefaultValueAttributeを作成できます。通常、メンバの既定値はその初期値になります。ビジュアルデザイナでは、その既定値を使用してメンバの値をリセットできます。コードジェネレータでも、既定値を使用して、メンバに対してコードを生成する必要があるかどうかを判断できます。

なんかIDEが勝手に吐くコードに関係ありそう。
逆に言えば、コンソールアプリでは無意味かも...?!

さらに引用:

private bool myVal=false;

[DefaultValue(false)]
public bool MyProperty {
   get {
      return myVal;
   }
   set {
      myVal=value;
   }
}

あれ?ちゃっかり初期化してる(-_-;)

半分やけくそでコンストラクタを書き換えてみる。

class Foo
{
    public Foo()
    {
        //書き加えた処理
        foreach (PropertyInfo fi in typeof(Foo).GetProperties())
        {
            AttributeCollection attrs =
                TypeDescriptor.GetProperties(this)[fi.Name].Attributes;
            fi.SetValue(
                this,
                ((DefaultValueAttribute)attrs[typeof(DefaultValueAttribute)]).Value,
                null);
        }
    }

    [DefaultValue(typeof(int), "100")]

    public int IntValue { get; set; }

    [DefaultValue(typeof(bool), "True")]
    public bool BoolValue { get; set; }

    [DefaultValue(typeof(Color), "White")]
    public Color ColorValue { get; set; }
}

コンストラクタでDefaultValueに設定した値で初期化されるようにしてみた。

実際に使ってみる。

Foo foo = new Foo();

Console.WriteLine("IntValue:{0}\nBoolValue:{1}\nColorValue:{2}\n",
    foo.IntValue,
    foo.BoolValue,
    foo.ColorValue);

//Output
//IntValue:100
//BoolValue:True
//ColorValue:Color [White]

これでイイとは思ってないけど、これでおわり。

StructLayoutとFieldOffset属性 - C#

noreply@blogger.com (y@s) — Thu, 25 Feb 2010 15:10:00 +0000

属性を学んでいてなかなかおもしろいなぁと感じたのでメモる。
StructLayoutとFieldOffsetを使用すると便利なモノができるようだ。

StructLayout - クラスまたは構造体のデータフィールドの物理的なレイアウトを制御できる。
FieldOffset - フィールドの物理的な位置を示す。

StructLayout属性でレイアウトの種類を指定して、FieldOffset属性で先頭からの距離をバイト単位で指定することになる。
下記の例ではbyte型のAlpha、Red、Green、Blueの計4つのフィールド、つまり4バイトの構造体を作成している。

[StructLayout(LayoutKind.Explicit)]
struct ARGBColor
{
    [FieldOffset(3)] public byte Alpha;
    [FieldOffset(2)] public byte Red;
    [FieldOffset(1)] public byte Green;
    [FieldOffset(0)] public byte Blue;
    [FieldOffset(0)] public uint Argb;
}

Alpha、Red、Green、Blueフィールドでは1バイトのデータにアクセスする。
Argbフィールドでは4バイトのデータにアクセスする。

Argbに値を設定するとAlpha、Red、Green、Blueのそれぞれに値が設定される。
またその逆にAlpha、Red、Green、Blueのそれぞれに値を設定するとArgb値も当然変化する。

すごく便利だ(^-^)

欲を言えば、public int Rgbとして、Alphaを省いたRGB値も取得できたらもっと良かったのだが、どうもうまくいかない(-_-;)

色を16進数で表す場合「ARGB」つまり、「Alpha、Red、Green、Blue」の順番となるので、FieldOffset属性に設定する値でその順番を間違えないように気を付けたい。

Example

ARGBColor color = new ARGBColor();
color.Argb = 0x8033ff;

FieldInfo[] fields = color.GetType()
    .GetFields(BindingFlags.Instance | BindingFlags.Public);

Console.WriteLine("{0,-6} {1,12}{2,12}", "Name", "hex", "int");
foreach (FieldInfo field in fields)
{
    Console.WriteLine("{0,-6}:{1,12}{2,12}",
        field.Name,
        Convert.ToString(Convert.ToInt64(field.GetValue(color)), 16),
        field.GetValue(color));
}

color.Alpha = 0xff;
color.Red = 0x33;
color.Green = 0x66;
color.Blue = 0x99;

Console.WriteLine("\n{0,-6} {1,12}{2,12}", "Name", "hex", "int");
foreach (FieldInfo field in fields)
{
    Console.WriteLine("{0,-6}:{1,12}{2,12}",
        field.Name,
        Convert.ToString(Convert.ToInt64(field.GetValue(color)), 16),
        field.GetValue(color));
}

Output

Name            hex         int
Alpha :           0           0
Red   :          80         128
Green :          33          51
Blue  :          ff         255
Argb  :      8033ff     8401919

Name            hex         int
Alpha :          ff         255
Red   :          33          51
Green :          66         102
Blue  :          99         153
Argb  :    ff336699  4281558681

続・画像ファイルのパスを取得する - C#

noreply@blogger.com (y@s) — Thu, 25 Feb 2010 11:00:00 +0000

前回の処理をもう少し見直してみる。

前回の処理では画像形式の種類を問わずファイルを取得しているので、特定のファイル形式のみを取得する処理にしたい。

取得したい画像形式を簡単に指定出来るようにしたいので引数として使用するenumを用意する。

[Flags]
public enum ImageTypeFlags
{
    BMP  = 1,
    EMF  = 1 << 1, //  2
    GIF  = 1 << 2, //  4
    ICO  = 1 << 3, //  8
    JPEG = 1 << 4, // 16
    PNG  = 1 << 5, // 32
    TIFF = 1 << 6, // 64
    WMF  = 1 << 7  //128
}

各画像形式には複数の拡張子が存在するのでその拡張子を直に取り出せるようにImageTypeFlagsをKeyにしたDictionaryを作成する。

Dictionary<ImageTypeFlags, string[]> extDict = ImageCodecInfo
    .GetImageDecoders()
    .ToDictionary(
        ici => (ImageTypeFlags)Enum.Parse(typeof(ImageTypeFlags),
            ici.FormatDescription, true),
        ici => ici.FilenameExtension.Split(';'));

ここで一つ問題がある。
ImageTypeFlagsの列挙子と上で取得するFormatDescriptionとが必ず一致する保証がない。
現在の.NET Frameworkのバージョンでは問題なく動作するが、今後サポートする画像形式が変更される可能性は決してゼロではないため、これについての対処がされていないという意味でちぃとマズイかも...

以下が本体。

string[] GetImageFiles(string root, SearchOption so)
{
    return GetImageFiles(root, so, (ImageTypeFlags)0xff); //255 = All
}

string[] GetImageFiles(
    string root, SearchOption so, ImageTypeFlags imgTypeFlags)
{
    IEnumerable<string> imgFiles = new string[0];

    foreach (ImageTypeFlags flg in Enum.GetValues(typeof(ImageTypeFlags)))
    {
        if ((imgTypeFlags & flg) != 0)
        {
            foreach (string sp in extDict[flg])
            {
                imgFiles = imgFiles.Concat(Directory.GetFiles(root, sp, so));
            }
        }
    }

    return imgFiles.ToArray();
}

ImageTypeFlags.Allがあった方が良かったかもしれないが、あるとそれに関する余計な処理が増えるので省き、メソッドのオーバーロードで対応した。

Usage

//JpegファイルとBitmapファイルを取得します。
string[] s = GetImageFiles(
    Environment.GetFolderPath(Environment.SpecialFolder.MyPictures),
    SearchOption.AllDirectories,
    ImageTypeFlags.JPEG | ImageTypeFlags.BMP);

これで簡単に画像ファイルのパスを取得できる。

画像ファイルのパスを取得する - C#

noreply@blogger.com (y@s) — Thu, 18 Feb 2010 10:00:00 +0000

画像ファイルのパスを取得するために、.NETで扱える画像の種類を取得する方として、他にも色々あるかもしれないが、私はこのようにする。

まず、ファイルのパスを取得するメソッドであるDirectory.GetFilesの引数のサーチパターンとして使用するものを用意する。

string[] IMAGE_SEARCH_PATTERN_ALL = ImageCodecInfo
    .GetImageDecoders()
    .Select(ici => ici.FilenameExtension.Split(';'))
    .Aggregate((current, next) => current.Concat(next).ToArray());

これを出力すると以下になる。

*.BMP
*.DIB
*.RLE
*.JPG
*.JPEG
*.JPE
*.JFIF
*.GIF
*.EMF
*.WMF
*.TIF
*.TIFF
*.PNG
*.ICO

これを使用した画像ファイルのパスを取得するメソッドを書いてみる。

string[] GetImageFiles1(string root, SearchOption so)
{
    List<string> imgFileList = new List<string>();

    foreach (string ext in IMAGE_SEARCH_PATTERN_ALL)
    {
        imgFileList.AddRange(Directory.GetFiles(root, ext, so));
    }

    return imgFileList.ToArray();
}

因みにDirectory.GetFilesは大文字と小文字を区別しない。
つまり、「jpg」も「JPG」も「Jpg」も拾う。

これを少し見直してみる。
Listを使うと少々処理が遅くなるので、これを使わない方法で書いてみる。

string[] GetImageFiles2(string root, SearchOption so)
{
    IEnumerable<string> imgFiles = new string[0];

    foreach (string ext in IMAGE_SEARCH_PATTERN_ALL)
    {
        imgFiles = imgFiles.Concat(Directory.GetFiles(root, ext, so));
    }

    return imgFiles.ToArray();
}

Listではなく、IEnumerableにしてConcatで配列をまとめているのだが、処理時間を計測するとIEnumerableを使用した方が若干だが速い。
こちらの方が低レベルな処理ということなのかな?

再帰でハマる - C#

noreply@blogger.com (y@s) — Tue, 16 Feb 2010 23:00:00 +0000

ループの代わりに再帰を使って繰り返し処理を行ってみたのだが、何やら予想外の動作になった。
「なぜそうなるのか？」についてまではまだたどり着いていないのであしからず。

N番目のフィボナッチ数を求める関数で説明すると、まずwhile文で単純に処理すると以下のようになる。

static int Fibonacci_1(int num)
{
    int x = 0,
        y = 1,
        old_x;

    while (num > 0)
    {
        old_x = x;
        x = y;
        y = old_x + y;
        num--;
    }

    return x;
}

Usage

int n = 12;
Console.WriteLine(
    "{0}th:{1}", n, Fibonacci_1(n));
//12th:144

今度は再帰を行い同様の処理をしてみる。

delegate int[] Fib(int[] n, Fib fib);
static int Fibonacci_2(int num)
{
    Fib fib = (xy, fn) =>
    {
        if (num > 0)
        {
            num--;
            fn(new[] { xy[1], xy[0] + xy[1] }, fn);
        }

        Console.WriteLine("{0}, {1}", xy[0], xy[1]);//①

        return xy;
    };

    return fib(new[] { 0, 1 }, fib)[0];
}

上記と同様に使用してみると結果は以下のようになった。

144, 233
89, 144
55, 89
34, 55
21, 34
13, 21
8, 13
5, 8
3, 5
2, 3
1, 2
1, 1
0, 1
12th:0

何番目を求めても答えは0。
コード内の①の部分で出力されている回数とその内容が逆転しているのがへんだ。
私の頭の中ではこれが出力されるのは最後の一度だけなのだが、どうにも理解し難い結果が出てくる。
もし仮に毎回出力されたとしても、なぜにその内容が逆転しているのか？
出力されるなら「0,1」から始まり「144,233」で終わるはず。

誰か分かる方がいらっしゃたら教えて下さいマセマセ m(__)m

一応手探りで解決したモノが以下。

static int[] Fibonacci_5(int num)
{
    if (num == 0){return new[] { 0, 1 };}

    return ((Func<int[], int[]>)((n) =>
    {
        return new[] { n[1], n[0] + n[1] };
    }))(Fibonacci_5(--num));
}

これで思った通りの結果が得られるわけだが...
しかし、なぜこれで良いのか書いた本人は分かっていない...　(^_^;)
勝手にぐるぐるループしてるけど、そのとき"n"の値も勝手に書き変わっているので、出力するのは1回にすれば正しい結果になるはず、という発想で書いてみただけ。

処理に掛る時間はおよそ倍になるのでボツですなぁ。(-ω-;)

行き当たりばったりで良しとする思考回路じゃないのねん!!

追記:
思った通りの動作となるように書き直したものです。

delegate int Fib(int n1, int n2, Fib fib);
static int Fibonacci_3(int num)
{
    Fib fib = (n1, n2, fn) =>
    {
        if (num > 0)
        {
            num--;
            return fn(n2, n1 + n2, fn);
        }
        else
        {
            return n1;
        }
    };

    return fib( 0, 1 , fib);
}

はい、私だけスッキリ(^-^)

欲を言えば、Javascriptで言うところのarguments.calleeのようなことができたら、もっとシンプルに書けるんだけどなぁ。

MSDNにもフィボナッチ数を求めるコードが載っていた。

必要な部分だけを抜き出し、メソッドにすると以下になる。

static int Fibonacci_7(int n)
{
    if (n <= 1) { return n; }
    return Fibonacci_7(n - 1) + Fibonacci_7(n - 2);
}

一見シンプルで良さげだが、実際に使ってみると超遅い。
まあ、参考までに。

フォルダ(ファイル)サイズを適切な単位に変換する - C#

noreply@blogger.com (y@s) — Sun, 31 Jan 2010 22:30:00 +0000

フォルダ(ファイル)サイズを取得したはイイが、バイトで表示されてもピンとこないので、適切な単位で表示したい。

まず、フォルダサイズを取得します。

/// <summary>
/// フォルダのサイズを取得します
/// </summary>
/// <param name="dirInfo">サイズを取得するフォルダ</param>
/// <returns>フォルダサイズ</returns>
public static long GetFolderSize(string path)
{
    return GetFolderSize(new DirectoryInfo(path));
}

public static long GetFolderSize(DirectoryInfo dirInfo)
{
    long size = 0;

    //フォルダ内のファイルサイズを計算します。
    foreach (FileInfo fi in dirInfo.GetFiles())
    {
        size += fi.Length;
    }

    //サブフォルダのサイズを合計します。
    foreach (DirectoryInfo di in dirInfo.GetDirectories())
    {
        size += GetFolderSize(di);
    }

    return size;
}

取得したサイズを適切な単位に変換します。

string GetFormatSizeString(float size)
{
    return GetFormatSizeString(size, 1024);
}

string GetFormatSizeString(float size, int p)
{
    return GetFormatSizeString(size, p, "#,##0.##");
}

string GetFormatSizeString(float size, int p, string specifier)
{
    string[] suffix = { "", "K", "M", "G", "T", "P", "E", "Z", "Y" };
    int index = 0;

    while (size >= p)
    {
        size /= p;
        index++;
    }

    return string.Format(
        "{0}{1}B",
        size.ToString(specifier),
        index < suffix.Length ? suffix[index] : "-");
}

当分はテラバイト(TB)まであれば十分だろうが念のため、出来る限り単位は付加されるようにしてある。
ulong.MaxValueをこのメソッドで変換すると、"16EB"となるため、これ以上の単位は不要とも思われるが、上の処理では一番大きな単位となる"YB"(ヨタバイト:yottabyte)以上の単位となる場合は"-B"となるようにしている。

Usage

string path = Environment.GetFolderPath(
        Environment.SpecialFolder.MyPictures);

long folderSize = GetFolderSize(path);

Console.WriteLine(folderSize);
Console.WriteLine(SizeFormat(folderSize));

念のため、"ディスク上のサイズ"ではなく、単なる"サイズ"と一致します。

Win APIを使用する

こんな感じでファイルサイズを変換してくれるモノもある。

[DllImport("shlwapi.dll", CharSet = CharSet.Auto)]
private static extern long StrFormatByteSize(
    long fileSize,
    [MarshalAs(UnmanagedType.LPTStr)] StringBuilder buffer,
    int bufferSize);

public static string GetFormatSizeString(long size)
{
    StringBuilder builder = new StringBuilder(32);
    StrFormatByteSize(size, builder, 32);
    return builder.ToString();
}

しかし、この処理は私が書いた上記の処理よりもパフォーマンスが悪い。
私が調べたところ、処理に掛る時間に約7倍の差が出た。
やはりやってみないと分からないことってありますねぇ。
APIを使ったり、unmanageコードを書けば何でも速くなると思っているアホにはなりたくないからね!!(^-^)v

指定されたパスがフォルダかを調べる - C#

noreply@blogger.com (y@s) — Sun, 31 Jan 2010 14:55:00 +0000

指定されたパスがフォルダかを調べるにはどうしたら良いのか。

ディレクトリであるかを調べるDirectory.Existsメソッドを使うと "C:\" などのルートディレクトリでもtrueを返す。

これを良しとしないのなら、File.GetAttributesメソッドで属性を取得して比較することになる。

bool ret = File.GetAttributes(path).Equals(FileAttributes.Directory);

これなら、指定したパスがルートディレクトリの場合、falseを返す。一応これで、期待通りの答えが返るワケだが... しかし、指定したパスが存在しない場合、例外が発生するのでこれを回避するために結局Directory.Existsメソッドを使い、指定したパスの存在チェックを行うとなると、なんか「え～～(-д-)」といった感じ。

下記のようにメソッドにしてtry catchで処理しても、パスが存在しないと余計に時間が掛る結果となった。

public static bool IsFolder(string path)
{
    try
    {
        return File.GetAttributes(path).Equals(FileAttributes.Directory);
    }
    catch (Exception ex)
    {
        if (ex.GetType() == typeof(FileNotFoundException))
        {
            return false;
        }
        throw ex;
    }
}

結局、時と場合に応じてこの二つの方法を使い分けるべきか。

もし、Directory.Existsを使うなら、こんな感じになるかな?

public enum FileType
{
    File = 0,
    Directory //(Folder)
}

//Sample - 1
public static bool IsFileType1(string path, FileType filetype)
{
    Func<string, bool>[] isType = new Func<string, bool>[]{
        File.Exists,
        Directory.Exists
    };

    return isType[(int)filetype](path);
}

//Sample - 2
public static bool IsFileType2(string path, FileType filetype)
{
    Func<string, bool> isType = filetype == FileType.File ?
        (Func<string, bool>)File.Exists : Directory.Exists;

    return isType(path);
}

Usage

string path = Path.Combine(
    Environment.GetFolderPath(Environment.SpecialFolder.MyPictures),
    @"test");

Console.WriteLine(IsFileType1(path, FileType.Directory));

LIAR GAME - 17Pokerのカラクリと矛盾

noreply@blogger.com (y@s) — Fri, 04 Dec 2009 01:00:00 +0000

LIAR GAMEトーナメント4回戦の中堅戦、17(セブンティーン)ポーカーの「ココおかしいです」。

録画していたのを最近見たのでタイムリーな話しではないことを十分理解した上で、
「そんなことはどうでもイイ!!」

※再放送を見たので、さらに書き加えました。

それでは本題へ。

念のため、17ポーカーを簡単に説明するとJ×4, Q×4, K×4, A×4, Jokerの計17枚で行うポーカーです。詳しいルールは番組のサイトでチェックして下さい。

今回取り上げるのは、秋山の要求によりヒンズーシャッフルを止めて、リフルシャッフルのみとなった6th Gameと7th Gameです。

リフルシャッフルにより規則的に変化するカードの並び順を調べることによって、秋山の「5枚交換による2連続4カードを本当に再現できるか?」を確かめる。

どうやって調べたか？ → サクッとJavascriptで。
規則的に動作するモノを再現するのはプログラミングは最も適しているトコロ。

そして、調べるうちに「おかしい(-_-;)」と思われるところがやはり出てきた。

新品のカードの並びを再現する

菊池の手掛かりをまとめると、

一番下は♠A
下から二番目は♠J
一番上はJoker

function create17Cards(){
    var
    suit = ["♥", "♣", "♦", "♠"],
    num = ["K", "Q", "J", "A"],
    cards = ["Jk"]; //Jk = Joker
    
    for (var i = 0; i < suit.length; i++) {
        for (var k = 0; k < num.length; k++) {
            cards.push(suit[i] + num[k]);
        }
    }
    
    return cards;
}

結果:上→下

[Jk][♥K][♥Q][♥J][♥A][♣K][♣Q][♣J][♣A][♦K][♦Q][♦J][♦A][♠K][♠Q][♠J][♠A]

後に秋山が行う説明の中での並び順とも完全に一致する。

リフルシャッフルを再現する

簡単に説明すると、二つに分けたカードを一枚づつ重ね合わせる方法のこと。
全カードの枚数が奇数(17枚)なのでカードを2分割するとき、「8,9」とするか「9,8」にするかで結果がことなるため重要なポイントとなる。
私が何度か試した結果とドラマ中の説明と一致するのは「8,9」であった。

//Perfect Shuffle
function riffleShuffle(cards, count){
    var tmp = [], cardsA, cardsB;
    
    for (var i = 0; i < count; i++) {
        cardsA = cards.slice(0, 8);
        cardsB = cards.slice(8);
        
        for (var k = 0; k < cardsB.length; k++) {
            tmp[k * 2] = cardsB[k];
        }
        
        for (var n = 0; n < cardsA.length; n++) {
            tmp[n + n + 1] = cardsA[n];
        }
        
        cards = tmp;
    }
    return cards;
}

if文を使わない方が直観的か?と感じたのでこのような形にしたが間違った結果は返さないのでこれで良しとする。

上のcreate17Cards関数で17枚のカードを生成し、このriffleShuffle関数で指定の回数だけシャッフルすると以下のような結果となる。

0: [Jk][♥K][♥Q][♥J][♥A][♣K][♣Q][♣J][♣A][♦K][♦Q][♦J][♦A][♠K][♠Q][♠J][♠A]
1: [♣A][Jk][♦K][♥K][♦Q][♥Q][♦J][♥J][♦A][♥A][♠K][♣K][♠Q][♣Q][♠J][♣J][♠A]
2: [♦A][♣A][♥A][Jk][♠K][♦K][♣K][♥K][♠Q][♦Q][♣Q][♥Q][♠J][♦J][♣J][♥J][♠A]
3: [♠Q][♦A][♦Q][♣A][♣Q][♥A][♥Q][Jk][♠J][♠K][♦J][♦K][♣J][♣K][♥J][♥K][♠A]
4: [♠J][♠Q][♠K][♦A][♦J][♦Q][♦K][♣A][♣J][♣Q][♣K][♥A][♥J][♥Q][♥K][Jk][♠A]
5: [♣J][♠J][♣Q][♠Q][♣K][♠K][♥A][♦A][♥J][♦J][♥Q][♦Q][♥K][♦K][Jk][♣A][♠A]
6: [♥J][♣J][♦J][♠J][♥Q][♣Q][♦Q][♠Q][♥K][♣K][♦K][♠K][Jk][♥A][♣A][♦A][♠A]
7: [♥K][♥J][♣K][♣J][♦K][♦J][♠K][♠J][Jk][♥Q][♥A][♣Q][♣A][♦Q][♦A][♠Q][♠A]
8: [Jk][♥K][♥Q][♥J][♥A][♣K][♣Q][♣J][♣A][♦K][♦Q][♦J][♦A][♠K][♠Q][♠J][♠A]

コンプリートシャッフルを8回行うと元の並びに戻ることが分かる。

カットを再現する

両プレイヤーそれぞれが上から何番目かを指定し、ディーラーがその位置でカードの位置を上下入れ替える。

function cut(cards, n){
    n = Math.max(Math.min(n, cards.length), 0);
    
    var
    cardsA = cards.slice(0, n),
    cardsB = cards.slice(n);

    return cardsB.concat(cardsA);
}

そして、最終的にディーラーを再現すると以下のようになる。

var Dealer = (function(){

    var cards = [];
    
    function create17Cards(){
        var
        suit = ["♥", "♣", "♦", "♠"],
        num  = ["K", "Q", "J", "A"],
        ret  = ["Jk"]; //Jk = Joker
        
        for (var i = 0; i < suit.length; i++) {
            for (var k = 0; k < num.length; k++) {
                ret.push(suit[i] + num[k]);
            }
        }
        
        return ret;
    }
    
    
    return {
        //set new cards
        newGame : function(){
            cards = create17Cards();
        },
        
        //Perfect Shuffle
        riffleShuffle: function(count){
            var tmp = [], cardsA, cardsB;
            
            for (var i = 0; i < count; i++) {
                cardsA = cards.slice(0, 8);
                cardsB = cards.slice(8);
                
                for (var k = 0; k < cardsB.length; k++) {
                    tmp[k * 2] = cardsB[k];
                }
                
                for (var n = 0; n < cardsA.length; n++) {
                    tmp[n + n + 1] = cardsA[n];
                }
                
                cards = tmp;
            }
        },
        
        //cut the cards
        cut:function(n){
            n = Math.max(Math.min(n, cards.length), 0);
            
            var
            cardsA = cards.slice(0,n),
            cardsB = cards.slice(n);
            
            cards = cardsB.concat(cardsA);
        },
        
        
        //First Deal
        firstDeal:function(){
            if(cards.length < 10) return;
            
            var
            decks = [[],[]],
            i     = 0;
            
            for (; i < 10; i++) {
                decks[i % 2].push(cards.shift());
            }
            
            return decks;
        },
        
        
        //change the card
        change: function(n){
            n = Math.min(Math.max(Math.min(n, 5), 1),cards.length);
            var ret = cards.slice(0, n);
            cards.splice(0, n);
            return ret;
        },
        
        
        //Remaining cards
        remainingCards:function(){
            return cards;
        }
    };
})();

そしてこれから、6th Gameと7th Gameを見ていく。

念のため:
プレイヤーは髪が長めの男の名が"秋山"。サングラスをした男が"菊池"。

6th Game

6th Gameからリフルシャッフルを何回行うことになっているのか明らかになっていない。
最初に決められた回数通りと考えるのが妥当だが、この17Pokerというゲームを始める際の説明として、「ヒンズーシャッフルとリフルシャッフルを行います。」と説明されているが、そのシャッフルを何回行うのかドラマ中に明言されていない。

カットのコール
菊池:9
秋山:2

秋山の最初の手札:ドラマ中一度も見せていない
菊池の最初の手札:♠K, ♦K, ♦J, ♠J, ♣A

5枚交換後の秋山の手札:♥A, Jk, ♠Q, ♦Q, ♥Q
1枚交換後の菊池の手札:♠K, ♦K, ♦J, ♠J, ♥J

秋山の方が先にカードの交換を行っているので、残されたカードは「♥A, Jk, ♠Q, ♦Q, ♥Q, ♥J, ?」の7枚だったということになる。
並び順までは分からないが最初の5枚の内、JokerとQeenが3枚、その後6枚目に必ず♥Jがある、ということまでは特定できる。

これと同じ状況を作り出せるか検証する。

検証用関数

function game(shuffleCount, cutNumA, cutNumB){

    var
    $div = $("<div>"),
    dealtCards, playerA, playerB;
    
    //Set new cards.
    Dealer.newGame();
    
    //Shuffle
    Dealer.riffleShuffle(shuffleCount);
    
    //Cut
    Dealer.cut(cutNumA);
    Dealer.cut(cutNumB);
    
    $div.append($("<span>").append([
        "shuffle: " + shuffleCount,
        "  cut 1: " + cutNumA,
        "  cut 2: " + cutNumB
    ].join("<br>")),"<br>");

    
    $div.append($("<span>").append(
        "before deal:" + Dealer.remainingCards().join(",")),
        "<br>");
    
    //deal cards
    dealtCards = Dealer.firstDeal();
    
    $div.append($("<span>").append([
        "       player A: " + dealtCards[0].join(","),
        "       player B: " + dealtCards[1].join(","),
        "remaining cards: " + Dealer.remainingCards().join(",")
    ].join("<br>")));
    
    return $div;    
}

この検証用関数を以下のように使用する。

for (var i = 0; i < 8; i++) {
    $(document.body).append(game(i, 9, 2));
}

6th Game Pattern:結果

shuffle:リフルシャッフルをする回数
cut 1,2:両プレイヤーが要求するカットの枚数
before deal:シャッフルとカットを終え、プレイヤーにカードを配る前のカードの並び順
player A:プレイヤーAに配られるカード
player B:プレイヤーBに配られるカード
remaining cards:プレイヤーにカードを配り終えた後、ディーラーの下に残されたカード

shuffle: 0
cut 1: 9
cut 2: 2
before deal:♦J,♦A,♠K,♠Q,♠J,♠A,Jk,♥K,♥Q,♥J,♥A,♣K,♣Q,♣J,♣A,♦K,♦Q
player A: ♦J,♠K,♠J,Jk,♥Q
player B: ♦A,♠Q,♠A,♥K,♥J
remaining cards: ♥A,♣K,♣Q,♣J,♣A,♦K,♦Q

shuffle: 1
cut 1: 9
cut 2: 2
before deal:♣K,♠Q,♣Q,♠J,♣J,♠A,♣A,Jk,♦K,♥K,♦Q,♥Q,♦J,♥J,♦A,♥A,♠K
player A: ♣K,♣Q,♣J,♣A,♦K
player B: ♠Q,♠J,♠A,Jk,♥K
remaining cards: ♦Q,♥Q,♦J,♥J,♦A,♥A,♠K

shuffle: 2
cut 1: 9
cut 2: 2
before deal:♥Q,♠J,♦J,♣J,♥J,♠A,♦A,♣A,♥A,Jk,♠K,♦K,♣K,♥K,♠Q,♦Q,♣Q
player A: ♥Q,♦J,♥J,♦A,♥A
player B: ♠J,♣J,♠A,♣A,Jk
remaining cards: ♠K,♦K,♣K,♥K,♠Q,♦Q,♣Q

shuffle: 3
cut 1: 9
cut 2: 2
before deal:♦K,♣J,♣K,♥J,♥K,♠A,♠Q,♦A,♦Q,♣A,♣Q,♥A,♥Q,Jk,♠J,♠K,♦J
player A: ♦K,♣K,♥K,♠Q,♦Q
player B: ♣J,♥J,♠A,♦A,♣A
remaining cards: ♣Q,♥A,♥Q,Jk,♠J,♠K,♦J

shuffle: 4
cut 1: 9
cut 2: 2
before deal:♥A,♥J,♥Q,♥K,Jk,♠A,♠J,♠Q,♠K,♦A,♦J,♦Q,♦K,♣A,♣J,♣Q,♣K
player A: ♥A,♥Q,Jk,♠J,♠K
player B: ♥J,♥K,♠A,♠Q,♦A
remaining cards: ♦J,♦Q,♦K,♣A,♣J,♣Q,♣K

shuffle: 5
cut 1: 9
cut 2: 2
before deal:♦Q,♥K,♦K,Jk,♣A,♠A,♣J,♠J,♣Q,♠Q,♣K,♠K,♥A,♦A,♥J,♦J,♥Q
player A: ♦Q,♦K,♣A,♣J,♣Q
player B: ♥K,Jk,♠A,♠J,♠Q
remaining cards: ♣K,♠K,♥A,♦A,♥J,♦J,♥Q

shuffle: 6
cut 1: 9
cut 2: 2
before deal:♠K,Jk,♥A,♣A,♦A,♠A,♥J,♣J,♦J,♠J,♥Q,♣Q,♦Q,♠Q,♥K,♣K,♦K
player A: ♠K,♥A,♦A,♥J,♦J
player B: Jk,♣A,♠A,♣J,♠J
remaining cards: ♥Q,♣Q,♦Q,♠Q,♥K,♣K,♦K

shuffle: 7
cut 1: 9
cut 2: 2
before deal:♣Q,♣A,♦Q,♦A,♠Q,♠A,♥K,♥J,♣K,♣J,♦K,♦J,♠K,♠J,Jk,♥Q,♥A
player A: ♣Q,♦Q,♠Q,♥K,♣K
player B: ♣A,♦A,♠A,♥J,♣J
remaining cards: ♦K,♦J,♠K,♠J,Jk,♥Q,♥A

注目すべきはリフルシャッフルを2回、または6回行った場合のディーラーに残されたカードだ。
結果、何度シャッフルをしたとしてもこのゲームのようなカードの並びにはならない。

それではどうのようなパターンなら再現されるのだろうか?
菊池の最初の手札から導き出せる可能性があるのでそれを手掛かりに探ってみる。

パターンの組み合わせは

コンプリートシャッフルを行う回数
両プレイヤーの要求するカットの枚数

全ての組み合わせを再現し、6th Gameで菊池が最初に手にした5枚のカードと同じカードが配られるパターンがあるかを調べてみる。

テスト用の関数が以下の通り

function samePattern(cards){
    var dealtCards;
    
    function same(cardsA, cardsB){
        var flg;
        
        for (var k = 0; k < cardsA.length; k++) {
            flg = false;
            
            for (var j = 0; j < cardsB.length; j++) {
            
                flg = cardsA[k] === cardsB[j];
                if (flg) {
                    //console.log("j:" + j);
                    break;
                }
            }
            
            if (!flg) {
                //console.log("not found:" + cardsA[k]);
                break;
            }
        }
        return flg;
    }
    
    //Shuffle count
    for (var i = 0; i < 8; i++) {
        //cut 1 Number
        for (var n = 0; n < 17; n++) {
            //cut 2 Number
            for (var m = 0; m < 17; m++) {
                Dealer.newGame();
                
                Dealer.riffleShuffle(i);
                Dealer.cut(n);
                Dealer.cut(m);
                
                dealtCards = Dealer.firstDeal();
                
                if (same(dealtCards[0], cards)) {
                    return [n, m, i];
                }
                
                if (same(dealtCards[1], cards)) {
                    return [n, m, i];
                }
            }
        }
    }
    
    return false;
}

そしてこのsamePattern関数を以下のように使用する。

var kikuchi = ["♠K","♦K","♦J","♠J","♣A"];
console.log(samePattern(kikuchi));//false

結果はfalse。
つまり、どのようなパターンであったとしても、菊池の最初の手札の組み合わせは生まれないのだ。

7th Game

このゲームでは秋山の要求により、さらに3回多くリフルシャッフルが行われている。
秋山:「...念のためあと2回、いや3回シャッフルしてくれ。」

カットのコール
秋山:8
菊池:7

秋山の最初の手札:♥J, ♦A, ♥A, ♠K, ♣K
菊池の最初の手札:♠A, ♣A, Jk, ♦K, ♥K

5枚交換後の秋山の手札:♠J, ♣Q, ♠Q, ♦Q, ♥Q
菊池は交換なし

最初の手札を配り終わった後のディーラーの下に残されているカードの上から5枚に秋山が5枚交換で手にしたカードがある組み合わせはあるか？

6th Gameと同じようにパターンを出してみる。

shuffle: 0
cut 1: 8
cut 2: 7
before deal:♠J,♠A,Jk,♥K,♥Q,♥J,♥A,♣K,♣Q,♣J,♣A,♦K,♦Q,♦J,♦A,♠K,♠Q
player A: ♠J,Jk,♥Q,♥A,♣Q
player B: ♠A,♥K,♥J,♣K,♣J
remaining cards: ♣A,♦K,♦Q,♦J,♦A,♠K,♠Q

shuffle: 1
cut 1: 8
cut 2: 7
before deal:♣J,♠A,♣A,Jk,♦K,♥K,♦Q,♥Q,♦J,♥J,♦A,♥A,♠K,♣K,♠Q,♣Q,♠J
player A: ♣J,♣A,♦K,♦Q,♦J
player B: ♠A,Jk,♥K,♥Q,♥J
remaining cards: ♦A,♥A,♠K,♣K,♠Q,♣Q,♠J

shuffle: 2
cut 1: 8
cut 2: 7
before deal:♥J,♠A,♦A,♣A,♥A,Jk,♠K,♦K,♣K,♥K,♠Q,♦Q,♣Q,♥Q,♠J,♦J,♣J
player A: ♥J,♦A,♥A,♠K,♣K
player B: ♠A,♣A,Jk,♦K,♥K
remaining cards: ♠Q,♦Q,♣Q,♥Q,♠J,♦J,♣J

shuffle: 3
cut 1: 8
cut 2: 7
before deal:♥K,♠A,♠Q,♦A,♦Q,♣A,♣Q,♥A,♥Q,Jk,♠J,♠K,♦J,♦K,♣J,♣K,♥J
player A: ♥K,♠Q,♦Q,♣Q,♥Q
player B: ♠A,♦A,♣A,♥A,Jk
remaining cards: ♠J,♠K,♦J,♦K,♣J,♣K,♥J

shuffle: 4
cut 1: 8
cut 2: 7
before deal:Jk,♠A,♠J,♠Q,♠K,♦A,♦J,♦Q,♦K,♣A,♣J,♣Q,♣K,♥A,♥J,♥Q,♥K
player A: Jk,♠J,♠K,♦J,♦K
player B: ♠A,♠Q,♦A,♦Q,♣A
remaining cards: ♣J,♣Q,♣K,♥A,♥J,♥Q,♥K

shuffle: 5
cut 1: 8
cut 2: 7
before deal:♣A,♠A,♣J,♠J,♣Q,♠Q,♣K,♠K,♥A,♦A,♥J,♦J,♥Q,♦Q,♥K,♦K,Jk
player A: ♣A,♣J,♣Q,♣K,♥A
player B: ♠A,♠J,♠Q,♠K,♦A
remaining cards: ♥J,♦J,♥Q,♦Q,♥K,♦K,Jk

shuffle: 6
cut 1: 8
cut 2: 7
before deal:♦A,♠A,♥J,♣J,♦J,♠J,♥Q,♣Q,♦Q,♠Q,♥K,♣K,♦K,♠K,Jk,♥A,♣A
player A: ♦A,♥J,♦J,♥Q,♦Q
player B: ♠A,♣J,♠J,♣Q,♠Q
remaining cards: ♥K,♣K,♦K,♠K,Jk,♥A,♣A

shuffle: 7
cut 1: 8
cut 2: 7
before deal:♠Q,♠A,♥K,♥J,♣K,♣J,♦K,♦J,♠K,♠J,Jk,♥Q,♥A,♣Q,♣A,♦Q,♦A
player A: ♠Q,♥K,♣K,♦K,♠K
player B: ♠A,♥J,♣J,♦J,♠J
remaining cards: Jk,♥Q,♥A,♣Q,♣A,♦Q,♦A

この結果から、2回シャッフルしたときにドラマと同じ組み合わせが再現できることが分かった。

しかし、秋山はシャッフルの回数を通常の回数に加えて更に3回行わせている。
ということは、シャッフルの回数は2回であるはずがないので、そうすると次にこの組み合わせが現れるのは10回目となる。
7th Gameはこのゲームの設定として、最初にリフルシャッフルを7回行うことを前提に成り立つことになる。
計10回もリフルシャッフルを行わせるというは少々疑問に感じるのだが、仮に10回行ったと仮定すると、それ以前のゲームまでは10 - 3で7回行っていたことになる。
そうすると、6th Gameの結果に益々無理が生じてくることになる。

つまり、7th Gameの結果から6th Gameは7回リフルシャッフルを行っていることになり、上で示したように、そのパターンで秋山が5枚交換でJoker + Q × 3の4カードを引き当てることは不可能なのだ。

ビットシフトの規則性を知りたくなった

noreply@blogger.com (y@s) — Thu, 26 Nov 2009 22:45:00 +0000

ビットシフトの規則性を知りたかったのでC#でちょっと調べてみた。

右シフト

int x = 144;
string binString = Convert.ToString(x, 2);
int ln = binString.Length;

Console.WriteLine(
    "target value:{0}\n" +
    "binary string:{1}\n" +
    "binary string length:{2}\n",
    x , binString, ln);

for (int i = 1; i <= ln; i++)
{
    int ret = x >> i;
    Console.WriteLine(
        "{0} >> {1} => {2}\t= {0} / {3}",
        x, i, ret, ret > 0 ? x / ret : 0);
}

Result:

target value:              144
binary string:        10010000
binary string length:        8

144 >> 1 => 72  = 144 /   2
144 >> 2 => 36  = 144 /   4
144 >> 3 => 18  = 144 /   8
144 >> 4 =>  9  = 144 /  16
144 >> 5 =>  4  = 144 /  36
144 >> 6 =>  2  = 144 /  72
144 >> 7 =>  1  = 144 / 144
144 >> 8 =>  0  = 144 /   0

左シフト

int n = 2;
for (int i = 1; i < 12; i++)
{
    int ret = x << i;
    Console.WriteLine(
        "{0} << {1} => {2}\t= {0} * {3}",
        x, i, ret, n);
    n = n * 2;
}

Result:

144 <<  1 =>    288     = 144 *    2
144 <<  2 =>    576     = 144 *    4
144 <<  3 =>   1152     = 144 *    8
144 <<  4 =>   2304     = 144 *   16
144 <<  5 =>   4608     = 144 *   32
144 <<  6 =>   9216     = 144 *   64
144 <<  7 =>  18432     = 144 *  128
144 <<  8 =>  36864     = 144 *  256
144 <<  9 =>  73728     = 144 *  512
144 << 10 => 147456     = 144 * 1024
144 << 11 => 294912     = 144 * 2048

2乗

int m = 2;
for (int i = 1; i < 12; i++)
{
    int ret = m << i;
    Console.WriteLine(
        "{0} << {1} => {2}\t= {0} * {0}\t{3}",
        m, i, ret, Convert.ToString(m, 2).PadLeft(12, '0'));
    m = m * 2;
}

Result:

   2 <<  1 =>       4   =    2 *    2   000000000010
   4 <<  2 =>      16   =    4 *    4   000000000100
   8 <<  3 =>      64   =    8 *    8   000000001000
  16 <<  4 =>     256   =   16 *   16   000000010000
  32 <<  5 =>    1024   =   32 *   32   000000100000
  64 <<  6 =>    4096   =   64 *   64   000001000000
 128 <<  7 =>   16384   =  128 *  128   000010000000
 256 <<  8 =>   65536   =  256 *  256   000100000000
 512 <<  9 =>  262144   =  512 *  512   001000000000
1024 << 10 => 1048576   = 1024 * 1024   010000000000
2048 << 11 => 4194304   = 2048 * 2048   100000000000

多少の規則性は見つけることができたかな?

脱線して関係ないことまで知ることになったのはいつものこと。
以下、関係なし。

ネイピア数:自然対数の底の値 (オイラー定数)

Math.E

結果は同じ

Math.Pow(Math.E, 2)
Math.Exp(2)

144 ... フィボナッチ数列の中の唯一の平方数(12番目)

Sqrt, Pow, Log
144 = x2

Math.Sqrt(144) //12

x = 122

Math.Pow(12, 2) //144

144 = 12x

Math.Log(144, 12) //2

この三つの関数の関係を表したかっただけ。

同じことをしている。

Math.Log10(144)
Math.Log(144, 10)

これも同じことをしている。

Math.Log(144)
Math.Log(144, Math.E)

指数をもとめるのに使用するMath.Logは便利だなぁ(^o^)、とか言いながらも実際はあまり使わない。(^_^;)

Keyword = 遅延 Lazy...?

noreply@blogger.com (y@s) — Wed, 25 Nov 2009 22:40:00 +0000

頭の中でどうも気になる「遅延」という言葉。
それが遅延処理とか遅延評価だとか、その辺のニュアンスはどうでもイイ。
頭の中で引っ掛かってしまったこのキーワードを調べずにはいられない衝動が...。
このブログのサブタイトルどおりの行動ということで。(^。^)y-.。o○

DOMContentLoaded

まず引っ掛かったのが「DOMContentLoaded」。
ページを構成するHTMLの解析が終わった段階で発生するのでloadイベントよりも先に実行される。

これはjQueryで実装されていて、ソースを見るとクロスブラウザに対応するのに結構手間の掛る処理を必要としていることが分かる。

jQueryを使用して書いたモノ、

$(function(){
  //something...
});

この中に書いたモノはloadイベントより早く実行されるのは知っていたが、どのように実装されているかまでは知らなかったのでソースを見るだけでもタメになった。

気になる人はbindReady Functionを見るとイイ。
例えば「DOMContentLoaded」の代わりに「onreadystatechange」を使ったり、またそれ以外の場合の対応など、その辺のことをちゃんと理解してないと出来ないなぁ...と。

自分で書くぐらいならjQueryを利用した方がイイ、というjQueryを使う理由が一つできた感じ。

Lazy Function

正直あまり遅延評価なるものを意識したことがなかったので、これを見て「オモシロイ」と思ってしまった。

Lazy Function Definition Pattern

特におもしろいと感じたのは#4。

引用:

var foo = function() {
    var t = new Date();
    foo = function() {
        return t;
    };
    return foo();
};

初回呼び出し時に自身を書き換えている。

つまり、fooは
初回呼び出し時

function() {
    var t = new Date();
    foo = function() {
        return t;
    };
    return foo();
};

初回呼び出し以降

function() {
    return t;
};

という形になる。

Wikipediaの言葉を借りて言うならば、「計算量の最適化」という発想がただ私自身になかっただけ、と言われればそれまでだが、確かにこのようなことを意識して書くのも大切なことだろうし、私的にはかなりツボに入っておもしろいと感じてしまった。

なぜ文字列リテラルのメソッドを呼び出すと遅いのか?

noreply@blogger.com (y@s) — Thu, 19 Nov 2009 22:30:00 +0000

Javascript 型判定の方法とその処理速度について:humming birdでの投稿の時点ではまだ分からなかったこと。

端的に言えば『[].constructor』より『"foo".constructor』の方が処理に時間が掛る。
文字列リテラルだけではなく、真偽値リテラル、数値リテラルも同様に他(例えば Array)と比べて処理に時間が掛る。

その理由が以下。

引用:
文字列リテラルの値でなら、String オブジェクトのどんなメソッドでも呼び出すことができます。JavaScript が自動的に文字列リテラルを一時的な String オブジェクトに変換し、メソッドを呼び出し、その一時的な String オブジェクトを破棄するのです。...
Literals - MDC

これは文字列リテラルの説明ですが、真偽値リテラルと数値リテラルも同様の理由と考えるのが妥当と思われる。

「instanceof」を使うと違いが分かる。
Example:

"foo" instanceof String // false

表にすると以下のようになる。

Value **instanceof** ObjectType
	Value	Result
String	"foo"	false
String	new String("foo")	true
Number	0	false
Number	new Number(0)	true
Boolean	true	false
Boolean	new Boolean(true)	true
Array	[]	true
Array	new Array([])	true
RegExp	/(?:)/	true
RegExp	new RegExp()	true
Object	{}	true
Object	new Object()	true

つまり、「文字列リテラル"foo"はインスタンスはStringのインスタンスではない。しかし、コンストラクタはStringですよ」という、ちょっと首を傾げる結果を返すということだ。

理由が分かってスッキリした。＼(^o^)／

でも、頻繁にメソッドを使用するならString オブジェクトを利用した方がイイってことにならないか?

Firefoxで処理に掛る時間を計測するとその差は約3倍。
construtorメソッドしか調べてないが、いちいち new String() とかするなんてハッキリ言って...

そんなのメンドクサイ(-_-;)