小编Tho*_*eia的帖子

我正在Haskell中实现N-Body模拟.https://github.com/thorlucas/N-Body-Simulation

现在,每个粒子计算其力,然后相对于彼此的粒子加速.换句话说,O(n²)力的计算.如果我要计算每个组合一次,我可以将其减少到O(n选择2).

let combs = [(a, b) | (a:bs) <- tails ps, b <- bs ]
    force = map (\comb -> gravitate (fst comb) (snd comb)) combs

但我无法弄清楚如何在不使用状态的情况下将这些应用于粒子.在上面的例子中,ps是[Particle]在哪里

data Particle = Particle Mass Pos Vel Acc deriving (Eq, Show)

从理论上讲,在一个有状态的语言,我只想能够遍历组合,从每一个计算从现行有关加速度a和b,然后更新各自Particle的ps加速度为我做到这一点.

我想过要做点什么foldr f ps combs.起始累加器将是当前的ps并且f将是一些函数,它接收每个comb并更新相关Particle的内容ps,并返回该累加器.对于这样一个简单的过程来说,这似乎非常耗费内存并且非常复

有任何想法吗？

在优化性能关键代码时，我注意到在std :: set上进行迭代有点慢。

然后，我编写了一个基准测试程序，并通过迭代器（auto it : vector）测试了向量的迭代速度，通过迭代器对集合进行了迭代，并通过索引（int i = 0; i < vector.size(); ++i）对向量进行了迭代。

容器的构造相同，具有1024个随机整数。（当然，由于我们正在使用集合，因此每个int都是唯一的）。然后，对于每次运行，我们循环遍历容器并将其int求和为long int。每次运行都有1000次迭代进行求和，并且对1000次运行进行了平均测试。

这是我的结果：

Testing vector by iterator
?           
Maximum duration: 0.012418
Minimum duration: 0.007971
Average duration: 0.008354

Testing vector by index
?           
Maximum duration: 0.002881
Minimum duration: 0.002094
Average duration: 0.002179

Testing set by iterator
?           
Maximum duration: 0.021862
Minimum duration: 0.014278
Average duration: 0.014971

如我们所见，通过迭代器对集合进行迭代比通过向量进行迭代慢1.79倍，而通过索引进行迭代的速度比向量慢6.87倍。

这里发生了什么？集合不仅是一种结构化的向量，可以检查每个项目在插入时是否唯一吗？为什么要这么慢？

编辑：谢谢您的答复！很好的解释。根据要求，这是基准代码。

#include <chrono>
#include <random>
#include <string>
#include <functional>
#include <set>
#include <vector>

void …

我需要存储一个枚举判别式向量来进行比较：

use std::mem;

enum Thing {
    Foo(usize),
    Bar(usize, usize),
}

let ds: Vec<mem::Discriminant<Thing>> = vec![/* ??? */];

// ...

let thing: Thing = Foo(1234);

for d in ds.iter() {
    if mem::discriminant(thing) == d {
        println!("yay");
    }
}

实际上，将使用宏来生成判别式列表，以便匹配枚举列表中的上下文。

例如，我们可能有这样的东西：

enum Thing {
    A(usize),
    B(f32),
    C(u8, u8, u8),
}

context_rule! {
    A(a) B(b) C(c) B(d) : a + b + c < d => C(b * c)
}

vec![A, B, C, B]它应该生成一个对应于要检查的判别式的向量。

我知道std :: set不允许非const访问它的项目.我知道将项目移出集合是不可能的 - 因为任何类型的非const访问都可能破坏集合的顺序.

但是,我们可以从集合中删除项目.这不会破坏它,因为它只会强制重组.那怎么回事,我们不能'弹出'一个项目？为什么我不能拿出物品并同时擦掉它？

我问的原因是 - 我需要一个有序的unique_ptrs容器.偶尔我需要从一个容器中"弹出"unique_ptrs并将它们转移到另一个容器中.必须订购它们才是我制作的定制仿函数.

我不明白为什么不应该允许弹出功能？

我创建了以下单元测试：

    <?php

    namespace Tests\Unit;

    use Tests\TestCase;
    use App\User;
    use App\Organization;

    class UserTest extends TestCase
    {
        public function testUserHasOwnedOrganization()
        {
            $user = factory(User::class)->create();
            $organization = factory(Organization::class)->create([
                'organizer_id' => $user->id,
            ]);

            $this->assertContains($organization, $user->owned_organizations);
        }
    }

当我运行它时，我得到：

SQLSTATE[HY000]: General error: 1 no such table: users

但是，当我打开时php artisan tinker：

>>> factory(App\User::class)->create()
=> App\User {#3048
     name: "Margret Armstrong",
     email: "shanel.cormier@example.net",
     email_verified_at: "2020-05-18 01:22:30",
     updated_at: "2020-05-18 01:22:30",
     created_at: "2020-05-18 01:22:30",
     id: 1,
   }

很明显，工厂在工作，桌子存在。

这里发生了什么？

谢谢，

我想补充一个“撰写”按钮到.bottomBar的.toolbar我NavigationView。

添加一个Spacer()简单的几乎居中对齐项目：

struct HomeView: View {
    var body: some View {
        NavigationView {
            Text("Hello, World!")
                .navigationTitle("Hello, World!")
                .toolbar {
                    ToolbarItem(placement: .bottomBar) {
                        HStack {
                            Spacer()
                            Button(action: { print("Pressed") }) {
                                Image(systemName: "plus.circle.fill")
                                    .imageScale(.large)
                                    .font(.title)
                            }
                        }
                    }
                }
        }
    }
}

这会产生以下结果：

不是我所期望的。更奇怪的是，这并不是完全居中对齐，而是偏离了几个像素。

那么我该怎么做：

1. 右对齐？

2. 居中对齐？

谢谢

在 L-System 符号中，模式看起来像这样：

A(a)<A(x)>B(b, c) if a+b+c < 10 => B(a+b, a+c)A(x+a+b+c)

我正在尝试编写 rust 宏来扩展这些。所以我有这样的事情：

macro_rules! test {
    ($lc:pat < $a:pat > $rc:pat) => { ... };
}

但它不会让我。它说：

error: `$a:pat` is followed by `>`, which is not allowed for `pat` fragments
 --> src/main.rs:7:23
  |
7 |     ($lc:pat < $a:pat > $rc:pat) => { log_syntax!($lc); log_syntax!($a); log_syntax!($rc); };
  |                       ^ not allowed after `pat` fragments
  |
  = note: allowed there are: `=>`, `,`, `=`, `|`, `if` or `in`

为什么在 pat …

所以也许我误解了 SwiftUI 的工作原理，但我已经尝试了一个多小时，但仍然无法弄清楚。

struct ContentView: View, AKMIDIListener {
    @State var keyOn: Bool = false

    var key: Rectangle = Rectangle()

    var body: some View {
        VStack() {
            Text("Foo")
            key
                .fill(keyOn ? Color.red : Color.white)
                .frame(width: 30, height: 60)
        }
        .frame(width: 400, height: 400, alignment: .center)
    }

    func receivedMIDINoteOn(noteNumber: MIDINoteNumber, velocity: MIDIVelocity, channel: MIDIChannel, portID: MIDIUniqueID? = nil, offset: MIDITimeStamp = 0) {
        print("foo")
        keyOn.toggle()
    }
}


struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
    }
}

所以这个想法很简单。我有一个使用 AudioKit …

Rust 使用起来chrono非常令人沮丧，因为它使得从时区转换非常困难。

例如：我的用户输入一个字符串。我使用NaiveDateTime::parse_from_str. 现在我想将其转换为DateTime<Local>.

不幸的是，我似乎无法找到如何这样做。使用Local::From不起作用。使用DateTime<Local>::from()也不行。两个结构都没有从 a 转换的方法NaiveDateTime，NaiveDateTime也没有转换为 的方法Local。

然而，我们可以做这样的事情：someLocalDateTime.date().and_time(some_naive_time)。那么为什么我们不能这样做Local::new(some_naive_date_time)呢？

另外，为什么我们不能跳过解析中的字段？我不需要秒，我不需要一年。为了假设当前的年份和 0 秒，我必须手动编写解析代码并从 ymd hms 构造日期时间。