3

是否/是否有函数std.algorithm可以std.range懒惰地计算前向差异？我需要这个来对一个范围内的排序元素（整数）进行不同的打包。整数恰好是SysTime时间戳。

更新：建议的解决方案：

/** Compute Forward Difference of $(D range).
 */
auto ref forwardDifference(bool reverse = false, Range)(in Range range)
    @safe pure nothrow if (isInputRange!Range)
{
    import std.algorithm: map;
    import std.range: zip, dropOne;
    static if (reverse)
        return range.zip(range.dropOne).map!(a => a[1] - a[0]);
    else
        return range.zip(range.dropOne).map!(a => a[0] - a[1]);
}

unittest {
    const i = [1, 5, 9, 17];
    import std.algorithm: equal;
    assert(equal(i.forwardDifference!false, [ -4, -4, -8]));
    assert(equal(i.forwardDifference!true,  [ +4, +4, +8]));
}

请评论解决方案。

4

3 回答 3

3

如果我理解正确，您的意思是这样的吗？

auto i = [1, 5, 9, 17];
writeln(i.zip(i.dropOne()).map!(a=>a[0] - a[1]));
于 2014-01-08T21:26:20.753 回答
2

另一种方法是制作自己的范围：

import std.range;
import std.stdio;

auto forwardDifference(Range)(Range r) if (isInputRange!Range)
{
    struct ForwardDifference
    {

        Range range;
        alias ElementType!Range E;
        E _front;
        bool needInitialize = true;

        this (Range range)
        {
            this.range = range;
        }

        E front()
        {
            if (needInitialize)
            {
                popFront();
            }
            return _front;
        }

        E moveFront()
        {
            popFront();
            return _front;
        }

        void popFront()
        {
            if (empty is false)
            {
                needInitialize = false;
                E rf = range.front;
                range.popFront();
                if (range.empty is false)
                {
                    _front = rf - range.front;
                }
            }
        }

        bool empty()
        {
            return range.empty;
        }
    }

    return ForwardDifference(r);
}
void main(string[] args)
{
    auto i = [1, 2, 3, 5, 7, 9];
    writeln(i.forwardDifference);
    stdin.readln;
}
于 2014-01-09T12:47:56.560 回答
0

请注意， given ，当它的类型与自身E e;不同时，这不起作用，例如，它的差异何时变为类型并且该算法无法实例化。这是一个更正的版本e-eEEstd.datetime.SysTimeDuration

auto forwardDifference(Range)(Range r) if (isInputRange!Range) {
import std.range: front, empty, popFront;

struct ForwardDifference {
    Range _range;
    alias E = ElementType!Range;
    typeof(_range.front - _range.front) _front;
    bool _needInitialize = true;

    this (Range range) { this._range = range; }

    auto ref front() {
        if (_needInitialize) { popFront(); }
        return _front;
    }

    auto ref moveFront() {
        popFront();
        return _front;
    }

    void popFront() {
        if (empty is false) {
            _needInitialize = false;
            E rf = _range.front;
            _range.popFront();
            if (_range.empty is false)
            {
                _front = _range.front - rf;
            }
        }
    }

    bool empty() { return _range.empty; }
}

return ForwardDifference(r);

}

现在自然的问题变成了：我们什么时候应该创建新的专门的惰性评估范围，比如这个，什么时候我们应该重用和重组现有的范围std.range？

于 2014-01-16T22:54:23.467 回答