标签: mutation

我想生成突变测试覆盖率.我在PI Test上做POC,但它没有参加我的测试课程而且失败了.我在pom.xml中配置了PTTest插件.我在pom.xml文件中检查了目标类包名称和目标测试类包名称是否正确.

我收到以下错误 -

10:50:29 AM PIT >> INFO : Mutating from D:\IR\workspace\cleanup_trunk\reporterDx-service\target\classes
10:50:29 AM PIT >> INFO : Verbose logging is disabled. If you encounter an problem please enable it before reporting an issue.
10:50:30 AM PIT >> INFO : Sending 0 test classes to slave
10:50:30 AM PIT >> INFO : Sent tests to slave
10:50:30 AM PIT >> INFO : Calculated coverage in 0 seconds.
10:50:30 AM PIT >> INFO : Created  0 mutation test units
[INFO] …

因此，我经常按照以下模式编写代码：

_list = list(range(10)) # Or whatever
_list = [some_function(x) for x in _list]
_list = [some_other_function(x) for x in _list]

等等

我现在在另一个问题上看到一条评论，它解释了这种方法每次如何创建一个新列表，最好对现有列表进行变异，如下所示：

_list[:] = [some_function(x) for x in _list]

这是我第一次看到此明确建议，我想知道其中的含义是什么：

1）突变是否节省内存？大概是在重新分配后对“旧”列表的引用将降为零，而“旧”列表将被忽略，但是在此之前会有延迟，此时我可能会使用比我使用时所需的更多内存重新分配而不是更改列表？

2）使用变异有计算成本吗？我怀疑就地更改某些内容比创建一个新列表并删除旧列表更昂贵？

在安全性方面，我编写了一个脚本对此进行测试：

def some_function(number: int):
    return number*10

def main():
    _list1 = list(range(10))
    _list2 = list(range(10))

    a = _list1
    b = _list2 

    _list1 = [some_function(x) for x in _list1]
    _list2[:] = [some_function(x) for x in _list2]

    print(f"list a: {a}")
    print(f"list b: {b}")


if __name__=="__main__":
    main()

哪个输出：

list a: [0, …

我正在研究编程语言理论,我无法弄清楚懒惰语言没有变异的可靠原因.谁知道原因？

我可以获取一个 Javascript 对象o并从中创建一个新的 Proxy 对象：

let p = new Proxy(object, { ... })

但是有没有办法改变现有对象引用以跟踪原始对象的更改？特别是，有没有办法可以从外部源跟踪对象上新键的添加？

我正在尝试改变一个突变。突变确实存在并且在我的 graphql 操场上运行良好。但是当我在我的反应组件中实现它时，我得到了错误。查询工作正常。顺便说一句，我的代码中需要客户端，所以我绝对必须使用 ApolloConsumer。

我尝试使用 client.mutate 像https://github.com/apollographql/apollo-client/issues/2762

export const LOGIN = gql`
  mutation LOGIN($email: String!, $password: String!) {
    login(email: $email, password: $password) {
      email
    }
  }
`;
class LoginComponent extends Component{
  render(){
    return(
      <ApolloConsumer>
        {client=>{
          return(
            <Button onClick={()=>{
              client
                .mutate({
                  mutation: LOGIN,
                  variables: {
                    email: "test@test.com",
                    password: "test"
                    }
                })
                .then(result => {
                  console.log('result', result)
                })
                .catch(err => {
                  console.log("err", err);
                  alert(err.toString());
                });
            }}> 
              OK
            </Button>
          )
        }}
      </ApolloConsumer>
    )  
  }
}

我希望获得成功，但我收到错误：GraphQL 错误：无法在类型“突变”上查询字段“登录”。（第 2 行，第 3 列）：登录（电子邮件：$email，密码：$password）{ ^

据我所知,Haskell的ST monad是独一无二的,它允许我描述一个本地使用可变内存的计算,但仍然提供一个纯粹的接口.也就是说,它允许我改变内存,只要该突变不会逃避计算.最简单的例子就是:

runST $ newSTRef "trying to return a memory reference."

这导致编译时错误(多酷!):

Couldn't match type ‘a’ with ‘STRef s a0’
  because type variable ‘s’ would escape its scope
This (rigid, skolem) type variable is bound by
  a type expected by the context: ST s a
  at <interactive>:1:1-18
Expected type: ST s a
  Actual type: ST s (STRef s a0)
In the second argument of ‘($)’, namely ‘newSTRef 0’
In the expression: runST $ newSTRef 0

我的理解是,如果允许可变引用逃脱计算,它可以在其他地方进行变异,并且我的ST计算可能不再具有纯接口(它可能在不同的调用上返回不同的值).

我的问题是:这是如何实施的？我看到runST和newSTRef的定义大量使用了RankNTypes,但是我无法理解这些类型如何产生上面的编译错误.

如果我们将以下代码段作为示例:

main() {
    List<int> array = [1, 2, 3, 4];
    List<int> newArray = change(array);

    print(array); // [99, 2, 3, 4]
    print(newArray); // [99, 2, 3, 4]
    print(newArray == array); // true
}

change(List<int> array) {
    var newArray = array;
    newArray[0] = 99;
    return newArray;
}

原始数组变异了.我期待通过将数组(对象)传递给更改函数并为其分配一个新变量,我可以避免变异.我知道built_collection库似乎是不可变集合的主要选择.是否存在任何原生方式的核心库,允许深度冻结或防止副作用(在另一个函数内的操作)？

我已经实现了一个遗传算法训练的神经网络，其中包含一个变异算子，如下所示：

def mutation(chromosome, mutation_rate):
  for gene in chromosome:
    if random.uniform(0.00, 1.00) <= mutation_rate:
      gene = random.uniform(-1.00, 1.00)

并且染色体最初是随机初始化的：

def make_chromosome(chromosome_length):
  chromosome = []
  for _ in range(chromosome_length):
    chromosome.append(random.uniform(-1.00, 1.00))
  return chromosome

在执行交叉时，后代染色体只能在该区间内有基因，[-1, 1]因为父染色体也只有在该区间内的基因。当后代发生突变时，它同样会将其基因保持在该区间内。

这似乎对某些问题有效，但对其他问题无效。如果神经元的最佳权重在 内[-1, 1]，那么遗传算法有效，但是如果神经元的最佳权重在不同的区间内呢？

例如，如果我使用分类误差低于 5% 的终止条件使用反向传播训练网络，我可以查看网络权重并查看诸如-1.49、1.98、等值2.01。我的遗传算法永远无法生成这些基因，因为基因在[-1, 1]和交叉和突变也不能产生该范围之外的基因。

看来我需要更好地定义搜索空间，如下所示：

# search space boundaries
S_MIN = -1.00
S_MAX = 1.00

# in mutation()
gene = random.uniform(S_MIN, S_MAX)

# in make_chromosome()
chromosome.append(random.uniform(S_MIN, S_MAX))

然后我可以根据问题设置搜索空间边界。但是我如何确定搜索空间呢？此信息不是先验已知的，而是通过训练网络找到的。但是如果训练需要知道搜索空间，那么我就处于停滞状态。

我可以将搜索空间设置为任意大（例如，肯定比必要的大），但是算法收敛得很慢。我需要至少知道遗传算法搜索空间的大致数字才能有效。

对于反向传播，搜索空间不是先验已知的，这无关紧要，但对于 GA 来说却是。

我正在阅读 Joseph Albahari 的书“C# 10 in a Nutshell”，它谈到“匿名类型的非描述性突变”，但我什至不知道突变是什么，在谷歌上我能找到的只是“突变测试”或“什么是突变”非破坏性突变？” 它们总是作为记录类型的附带功能而结束。有人可以帮我分解一下吗？一些例子将不胜感激！

我是 GraphQL 的新手，但我真的很喜欢它。现在我在玩接口和联合，我面临着突变的问题。

假设我有这个架构：

interface FoodType {
  id: String
  type: String
}

type Pizza implements FoodType {
  id: String
  type: String
  pizzaType: String
  toppings: [String]
  size: String
}

type Salad implements FoodType {
  id: String
  type: String
  vegetarian: Boolean
  dressing: Boolean
}

type BasicFood implements FoodType {
  id: String
  type: String
}

现在，我想创造新的食物，所以我开始做这样的事情：

type Mutation {
    addPizza(input:Pizza):FoodType
    addSalad(input:Salad):FoodType
    addBasic(input:BasicFood):FoodType
}

这不起作用有两个原因：

1. 如果我想传递一个对象作为参数，这个对象必须是“输入”类型。但是“Pizza”、“Salad”和“BasicFood”只是“类型”。
2. 输入类型不能实现接口。

所以，我的问题是：如何在接口的这种上下文中处理突变而不必过多地复制类型？我想避免使用 Pizza 类型的查询和 InputPizza 类型的突变。

感谢您的帮助。