小编Bea*_*ker的帖子

我试图将此C#代码转换为F#:

double[,] matrix;

public Matrix(int rows, int cols)
    {
        this.matrix = new double[rows, cols];
    }

 public double this[int row, int col]
    {
        get
        {
            return this.matrix[row, col];
        }
        set
        {
            this.matrix[row, col] = value;
        }
    }

基本上我最大的问题是在F#中创建索引器.网络上的任何地方我找不到任何可以应用的东西.我包括了该类的其他几个部分,以防将索引器合并到Matrix类型中并不明显.所以一个好的答案将包括如何从这里的三个部分中制作一个完整的类型,以及可能需要的任何其他东西.另外,我知道F#powerpack中的矩阵类型,但是我试图通过将我理解的C#项目转换为F#来学习F#.

提前致谢,

短发

我最近问了一个问题： 在F＃中重播记录的数据流，并将该代码与我在这里找到的功能的子集 结合在一起：http : //www.mattssoftwareblog.com/?p=271，看起来像这样：

#r "System.Reactive"
#r "System.CoreEx"
#r "FSharp.PowerPack"
#r "WindowsBase"
#r "PresentationCore"
#r "PresentationFramework"
#r "System.Xaml"
#r "System.Interactive.dll"

open System
open System.Linq
open System.Collections.Generic
open System.Net
open System.IO
open System.Threading
open System.Windows
open System.Windows.Input
open System.Windows.Controls
open System.Windows.Shapes
open System.Windows.Media
open System.Xaml

我需要使用此处生成的事件（来自我之前的SO问题）：

let prices = [ (0, 10.0); (1000, 10.5); (500, 9.5); (2500, 8.5); (500, 10.0); (1000, 10.5); (500, 9.5); (2500, 8.5) ]

let evt = new Event<float>()
async { for delay, price …

假设通过编译代码字符串在内存中创建（可执行）程序集。然后我想将这个程序集对象序列化为一个字节数组，然后将其存储在数据库中。然后我想从数据库中检索字节数组并将字节数组反序列化回程序集对象，然后调用程序集的入口点。

起初，我只是尝试像处理 .net 中的任何其他简单对象一样执行此序列化，但显然这不适用于程序集对象。程序集对象包含一个名为 GetObjectData 的方法，该方法获取重新实例化程序集所需的序列化数据。所以我对如何将所有这些拼凑成我的场景有些困惑。

答案只需要展示如何获取程序集对象，将其转换为字节数组，将其转换回程序集，然后在反序列化的程序集上执行入口方法。

我已经在领域的SQL数据库记录实时股票行情Id,Last和TimeStamp.最后是当前股票价格(作为双倍),并且TimeStamp是DateTime记录价格变化的时间.

我希望以与它相同的方式重播此流,这意味着如果价格变化最初相差12秒,则价格变化事件触发(或类似的事情)应该相隔12秒.

在C#中,我可能会创建一个集合,DateTime然后通过使用时间差来触发事件来对其进行排序,以了解何时触发下一个价格变化.我意识到F#有很多与事件有关的很酷的新东西,但我不知道我怎么会在F#中开始这个.关于如何处理此问题的任何想法/代码片段/有用的链接？

我想使用Roslyn对以下类执行反射样式操作:

public abstract class MyBaseClass
{
    public bool Method1()
    {
        return true;
    }
    public bool Method2()
    {
        return true;
    }
    public void Method3()
    {
    }
}

基本上我想这样做,但与罗斯林:

BindingFlags flags = BindingFlags.Public | 
                     BindingFlags.Instance;
MethodInfo[] mBaseClassMethods = typeof(MyBaseClass).GetMethods(flags);
foreach (MethodInfo mi in mBaseClassMethods)
{
    if (mi.GetParameters().Length == 0 && mi.ReturnType == typeof(void))
    {
        methodInfos.Add(mi);
    }
    if (mi.GetParameters().Length == 0 && mi.ReturnType == typeof(bool))
    {
        methodInfos.Add(mi);
    }
}

基本上,我想获得符合我在上面的反射示例中使用的标准的方法列表.此外,如果有人知道一个网站,解释如何做反射像操作与罗斯林,请随时指出我的方向.我一直在寻找几个小时,似乎无法在这方面取得进展.

提前致谢,

短发

我试图弄清楚如何在 Tensorflow 中截取动态确定的图像。下面是我试图完成的一个例子，但我似乎无法让它工作。本质上，我想在图形中提供图像和该图像的裁剪值，然后继续对这些裁剪的部分进行其他计算。我目前的尝试：

import tensorflow as tf
from matplotlib import pyplot as plt
import numpy as np

sess = tf.InteractiveSession()

img1 = np.random.random([400, 600, 3])
img2 = np.random.random([400, 600, 3])
img3 = np.random.random([400, 600, 3])

images = [img1, img2, img3]

img1_crop = [100, 100, 100, 100]
img2_crop = [200, 150, 100, 100]
img3_crop = [150, 200, 100, 100]

crop_values = [img1_crop, img2_crop, img3_crop]

def crop_image(img, crop):
    tf.image.crop_to_bounding_box(img,
                                  crop[0],
                                  crop[1],
                                  crop[2],
                                  crop[3])


image_placeholder = tf.placeholder("float", [None, 400, 600, 3])
crop_placeholder = …

这是我试图翻译的 C# 代码：

public bool equals(Matrix matrix, int precision)
    {

        if (precision < 0)
        {
            throw new MatrixError("Precision can't be a negative number.");
        }

        double test = Math.Pow(10.0, precision);
        if (double.IsInfinity(test) || (test > long.MaxValue))
        {
            throw new MatrixError("Precision of " + precision
                    + " decimal places is not supported.");
        }

        precision = (int)Math.Pow(10, precision);

        for (int r = 0; r < this.Rows; r++)
        {
            for (int c = 0; c < this.Cols; c++)
            {
                if ((long)(this[r, c] * precision) …

我正在尝试将一些C#代码转换为F#并遇到了一些小问题.这是我已经使用的F#代码:

open System
open System.Collections
open System.Collections.Generic

type Chromosome<'GeneType>() =
    let mutable cost = 0
    let mutable (genes : 'GeneType[]) = Array.zeroCreate<'GeneType> 0
    let mutable (geneticAlgorithm : GeneticAlgorithm<'GeneType>) = new GeneticAlgorithm<'GeneType>()

    /// The genetic algorithm that this chromosome belongs to.
    member this.GA
        with get() = geneticAlgorithm
        and set(value) = geneticAlgorithm <- value

    /// The genes for this chromosome.
    member this.Genes
        with get() = genes
        and set(value) = genes <- value

    /// The cost for this chromosome.
    member this.Cost
        with get() …

我有一个使用app.config文件的控制台应用程序但是我无法弄清楚如何在命令行参数中包含它,以便当我使用fsc.exe以编程方式编译时,输出将创建Program.exe.config.现在我的解决方法是将app.config重命名为Program.exe.config并将其复制到与Program.exe相同的输出位置.我需要的是fsc.exe命令行参数来执行此操作,但是我怀疑csc.exe将具有与fsc.exe相同或非常接近的内容,因此如果你知道它在csc.exe中是什么我会试试看.

短发

我想使用以下类作为一个具体的例子逐步构建一个新的IDocument对象.您可以从任何您喜欢的对象开始,并使用您喜欢的任何中间对象,只要生成的对象是一个IDocument,它代表最后的完整类.

步骤#1:添加一个名为MyNamespace的新命名空间.打印出当前对象应该如下所示:

namespace MyNamespace
{
}

步骤2:向名为MyClass的命名空间添加一个新类.打印出当前对象应该如下所示:

namespace MyNamespace
{
    public class MyClass
    {
    }
}

步骤3:向此类添加一个名为MyMethod的新方法.打印出当前对象应该如下所示:

namespace MyNamespace
    {
        public class MyClass
        {
            public void MyMethod()
            {
            }
        }
    }

我遇到的问题是,理论上似乎有很多方法可以解决这个问题,或者至少错误地断定你可以解决这个问题.各种不同对象中的无尽方法和构造函数,如WithChanges,UpdateDocument,各种语法对象上的方法,ParseCompilationUnit等.

基本上,我想以增量的方式构建它,在每个步骤都有一个独特的对象,例如,我可以打印到控制台,而不是一个在一行中创建整个事物的大声明.我已经多次阅读了6月发布的CTP所附的所有文档,正如我所提到的,我在各种构造函数和方法的看似无穷无尽的组合中迷失了.此外,我也对将性能考虑在内的方式感兴趣.

我是WebJobs的新手,我正在努力寻找一些看似微不足道的东西.我有一个名为"mydatastorage"的存储帐户,以及一个名为"mydatacontainer"的容器.我已经在网上搜索了一个星期,现在尝试执行以下基本方案:

我有大量的blob(已存储在Azure中)是html文件.我编写了一些代码,可以使用html字符串并将其转换为TableEntity.然后我想将TableEntity保存到表"mydatatable".看来我可以使用一个[Table]属性来简化将实体保存到表中的过程,或者在方法调用中将其手动保存到表中.我的问题是让方法签名正确,然后如何让blob进入该方法.我对所有属性感到困惑,比如[Blob],[BlobTrigger]和类型ICollector<T>以及使用它们的正确方式(以及何时).如果有人知道一个解释类似情况的教程,我很乐意了解它.

我正在尝试将以下C#转换为F#:

    public class Matrix
    {
       double[,] matrix;

public int Cols
        {
            get
            {
                return this.matrix.GetUpperBound(1) + 1;
            }
        }

public int Rows
        {
            get
            {
                return this.matrix.GetUpperBound(0) + 1;
            }
        }

       public Matrix(double[,] sourceMatrix)
       {
        this.matrix = new double[sourceMatrix.GetUpperBound(0) + 1, sourceMatrix.GetUpperBound(1) + 1];
        for (int r = 0; r < this.Rows; r++)
        {
            for (int c = 0; c < this.Cols; c++)
            {
                this[r, c] = sourceMatrix[r, c];
            }
        }
       }

       public double this[int row, int col]
       {
         get …

我有一个序列,它是一个字符序列,大多数是零,一个非常小的块看起来像这样:

0001001099991091010000100005480010000

我想得到由一个或多个零分隔的所有碎片.所以在上面的例子中,返回的正确值是:

1,1,99991,91,1,1,548,1(逗号仅供参考)

我认为向量列表最适合作为返回的数据结构,但我可以使用任何合理的方法.我有成千上万的字符串,每个字符串最多只有一千个字符.但是唯一的字符是0到9.这似乎可能是一个正则表达式问题,但我的正则表达式技能还不够好,甚至不能确定它是一个很好的正则表达式问题.如果一个正则表达式是答案,有人可以帮我解决这个问题吗？