主页 / coding / 问题

全部问题(coding)

Martin Hope
user3414663
Asked: 2024-11-26 13:19:41 +0800 CST
  • 8

在 Polars 中您如何表达身份认同的表达？

我这样表达的意思是idexpr，当你这样做时，lf.filter(idexpr)你就得到了全部lf。

SELECT(*)与SQL类似。

我采用如下逻辑表达方式

idexpr = (pl.col("a") == 0) | (pl.col("a") != 0)
python
Martin Hope
Ogs
Asked: 2024-11-26 06:40:16 +0800 CST
  • 8

我想使用 HH 包创建一个李克特图，该图结合了每个条形类别中的视觉模式（例如阴影），以提高色盲用户的可访问性。

显然，对于客户来说，仅有灰度或其他适合色盲的颜色是不够的。

每个条形图的不同类别（例如非常高兴、高兴、既不高兴也不悲伤、悲伤、非常悲伤）除了不同的颜色外，还必须包含一些图案或其他视觉区别（例如符号）。

这是一个可重现的例子：

样本数据：

## Dataframe with the necessary variables
df <- data.frame(institutt = c("institutt1", "institutt2"), 
                 Spørsmål = c("q1", "q1"), 
                 Veryhappy = c(3, 5), 
                 Happy = c(2, 4),
                 Neithernor = c(3, 2), 
                 Sad = c(4, 3), 
                 Verysad = c(5, 2))

起始情节：

install.packages("HH")
library(HH)
likert_plot <- df %>%  
    likert(grouping = df$institutt,
           as.percentage = TRUE)

这将产生：

这个数字

我如何在“非常高兴”、“高兴”等类别中添加线条、十字或符号来区分它们？

Martin Hope
Aravind S
Asked: 2024-11-26 01:50:38 +0800 CST
  • 8

我有此代码可以将一些 json 数据从 Terraform 写入 Vault，并且我已将这些资源添加到 main.tf 中 -

provider "vault" {
address = "https://secrets.staging.hulu.com"

auth_login {
   path = "auth/aws/login"
   method = "aws"
   namespace = var.vault_namespace
   parameters = {
      role         = "service-${var.yp_service_id}-tfe"
      header_value = var.header_value
      sts_region   = local.region
    }
  }
}

resource "vault_generic_secret" "example" {
   path      = "kv/${var.yp_service_id}/secret"
   data_json = var.secret
}

data vault_generic_secret example {
  depends_on = [vault_generic_secret.example]
  path      = "kv/${var.yp_service_id}/secret"
}

我要写入的数据是 JSON 格式的，看起来像这样，我认为这是一个有效的 JSON 数据 -

{
  "DD_API_KEY": "*****************",
  "DD_APP_KEY": "*****************",
  "DD_SITE": "datadoghq.com"
}

我已经在variables.tf中声明了变量-

variable "address" {
  type        = string
  description = "vault address"
  default     = "https://secrets.staging.dummy.com"
}

variable "vault_namespace" {
  type        = string
  description = "vault namespace"
  default     = "5f8dd98fc08eda598857b651"
}

variable "header_value" {
  type        = string
  description = "vault header"
  default     = "secrets.staging.dummy.com"
}

variable "secret" {
  description = "Sensitive secrets for the service"
  type        = map(string)
  sensitive   = true
}

variable "data_json" {
  description = "Sensitive secrets for the service"
  type        = map(any)
  sensitive   = true
  default     = {}
}

但是当我运行 Terraform Plan 时，我不断收到此错误 -

Waiting for the plan to start...

Terraform v1.7.5
on linux_amd64
Initializing plugins and modules...
╷
│ Error: Incorrect attribute value type
│ 
│   on main.tf line 173, in resource "vault_generic_secret" "example":
│  173:   data_json = var.secret
│ 
│ Inappropriate value for attribute "data_json": string required.
╵
Operation failed: failed running terraform plan (exit 1)

我如何在此处设置值data_json？我遗漏了什么吗？顺便说一下，这是 1.7.5 版本。提前致谢！

json
Martin Hope
Sprotte
Asked: 2024-11-25 23:47:51 +0800 CST
  • 8

我正在阅读 Stroustrup 编写的《编程：C++ 原理与实践》第 4 版，我对一些旨在说明复制构造函数/复制赋值/移动构造函数/移动赋值/析构函数语言特性的代码的输出感到困惑。以下代码大部分摘自本书，并实现了一个简单的类型，X以便上述运算符（以及构造函数）在调用时输出显式信息。

#include <iostream>
#include <string>
#include <vector>
using std::cout;
using std::string;
using std::vector;

struct X {
    int val;

    void out(const string& s, int nv) {
        cout << this << "->" << s << ":" << val << "(" << nv << ")\n"; 
    }

    X() { out("X()",0); val=0; }

    explicit X(int x) { out("X(int)",x); val=x; }

    X(const X& x) { out("X(X&)", x.val); val=x.val; }

    X& operator=(const X& x) { 
        out("X copy assignment", 0); 
        val=x.val; 
        return *this; }

    X(X&& x) {
        out("X(X&&)",x.val);
        val = x.val;
        x.val = 0; 
    }

    X& operator=(X&& x) {
        out("X move assignment", x.val);
        val = x.val;
        x.val = 0;
        return *this;
    }

    ~X() { out("~X()", 0); }
};

X copy(X a) {
    cout << "copy()\n";
    return a;
}

int main() {
    X loc {4};
    X loc2 {12};
    loc2 = copy(loc);
    cout << "Done\n";
}

我运行该程序时看到的输出如下：

0x16d1370bc->X(int):1(4)
0x16d1370b8->X(int):-1834548312(12)
0x16d1370b0->X(X&):1829990608(4)
copy()
0x16d1370b4->X(X&&):1(4)
0x16d1370b8->X move assignment:12(4)
0x16d1370b4->~X():0(0)
0x16d1370b0->~X():0(0)
Done
0x16d1370b8->~X():4(0)
0x16d1370bc->~X():4(0)

我理解此输出的前四行——它们来自两个局部变量loc和的构造函数loc2、来自的按值调用的复制构造函数copy以及来自函数体的打印copy。我对下一行感到困惑——即对移动构造函数的调用。我原本以为只是看到对移动赋值运算符的调用。为什么这里调用移动构造函数（我不认为有任何对象正在构造？）？它在什么情况下被调用？特别是，我没有看到具有由移动构造函数打印的内存地址的对象构造，所以我很困惑该对象来自哪里。

感谢您的帮助，很抱歉我是 C++ 新手。如果相关的话，我正在用编译此程序g++ -Wall -std=c++20。输出一直保留不同的编译优化级别。

c++
Martin Hope
Ronny M
Asked: 2024-11-25 13:35:44 +0800 CST
  • 8

目的是根据乙烷蒸汽气化反应产物和反应物（蒸汽+C2H6 的摩尔比为 4:1）的吉布斯生成能，计算 1000K 时混合物的热力学平衡组成，如下所示：

from gekko import GEKKO     
m = GEKKO(remote=True)
x = m.Array(m.Var,13,value=1,lb=1e-27,ub=20.0)
H2,H2O,CO,O2,CO2,CH4,C2H6,C2H4,C2H2,lamda1,lamda2,lamda3,summe= x
H2.value = 3.0
H2O.value = 1.0
CO.value = 0.5
O2.value = 0.001
CO2.value = 0.5
CH4.value = 0.1
C2H6.value = 0.000215
C2H4.value = 0.00440125
C2H2.value = 0.0041294
summe.value = 8.0
lamda1.value = 1.0
lamda2.value = 1.0
lamda3.value = 1.0
eq1 = m.Param(value=14)
eq2 = m.Param(value=4)
eq3 = m.Param(value=2)
summe = m.Var(H2 + O2 + H2O + CO + CO2 + CH4 + C2H6 + C2H4 + C2H2)
lamda2 = m.Var((-1)*m.log(H2 / summe) / 2)
lamda1 = m.Var(46.03 / 1.9872 - m.log(H2O / summe) + 2 * lamda2)
lamda3 = m.Var(47.942 / 1.9872 - m.log(CO / summe) + lamda1)
m.Equation(m.exp(-4.61 / 1.9872 - 4 * lamda2 - lamda3) * summe == CH4)
m.Equation(m.exp(-28.249 / 1.9872 - 4 * lamda2 - 2 * lamda3) * summe == C2H4)
m.Equation(m.exp(-40.604 / 1.9872 - 2 * lamda2 - 2 * lamda3) * summe == C2H2)
m.Equation(m.exp(-26.13 / 1.9872 - 6 * lamda2 - 2 * lamda3) * summe == C2H6)
m.Equation(m.exp(94.61 / 1.9872 - 2 * lamda1 - lamda3) * summe == CO2)
m.Equation(m.exp(-2 * lamda1) * summe == O2)
m.Equation(2 * CO2 + CO + 2 * O2 + H2O  == eq2)
m.Equation(4 * CH4 + 4 * C2H4 + 2 * C2H2 + 2 * H2 + 2 * H2O + 6 * C2H6  == eq1)
m.Equation(CH4 + 2 * C2H4 + 2 * C2H2 + CO2 + CO + 2 * C2H6  == eq3)
m.Minimize((summe-(H2 + O2 + H2O + CO + CO2 + CH4 + C2H6 + C2H4 + C2H2))**2)
m.options.IMODE = 3 #IPOPT
m.options.MAX_ITER = 1000
m.options.OTOL = 1e-10
m.options.RTOL = 1e-10
m.solve()
print('x: ', x)
print('Objective: ',m.options.OBJFCNVAL)

EXIT: Optimal Solution Found. 
The solution was found. 
The final value of the objective function is    81.0000000000000     

---------------------------------------------------
Solver         :  IPOPT (v3.12)
Solution time  :   1.169999998819549E-002 sec
Objective      :    81.0000000000000     
Successful solution
---------------------------------------------------

x:  [[5.797458326] [1.202541674] [1.202541674] [1.6791020526e-21]
[0.79745832603] [1.6503662452e-22] [3.2694282596e-27] [1.1255712085e-27]
[1e-27] [2.185089969] [2.185089969] [2.185089969] [9.5605307091]]

然后使用 GRG 作为优化器：

Excel 工作表输出

两种解决方案仍然不同。有趣的是，（约束）根查找器的输出仍然不同，但同时收敛：

Total number of equations:  13  
Number of implicit equations:  4  
Number of explicit equations:  9  
Solution method  CONSTRAINED  
Convergence tolerance:  1e-07  
# of iterations used:  8  

CO  1.685236
H2  5.118105
H2O  1.387357
SUM  8.899115  
C2H2  0.0041294  
C2H4  0.0044224  
C2H6  0.0092403  
CH4  0.2269213  
CO2  0.0522585  
lamda1  1.537016  
lamda2  0.2765838  
lamda3  2.53957  
O2  0.4114448

以下是各种解决方案的比较：

解向量 x 壁虎 EXCEL表格 寻根器 GEKKO-最终版
H2：1 5.797458326 5.344360712 5.118105 5.219
水：2 1.202541674 1.521995663 1.387357 1.681
二氧化碳：3 1.202541674 1.388351672 1.685236 1.581
氧气：4 1.6791020526e-21 5.82E-21 0.4114448 1e-5
二氧化碳：5 0.79745832603 0.544826 0.0522585 0.3693
通道4: 6 1.6503662452e-22 0.0668213 0.2269213 0.05
乙烷：7 3.2694282596e-27 1.70E-07 0.0092403 1e-5
乙烷：8 1.1255712085e-27 9.74E-08 0.0044224 1e-5
乙烷：9 1e-27 3.25E-10 0.0041294 1e-5
lamda1：10 2.185089969 24.3878385 1.537016
lamda2：11 2.185089969 0.253110984 0.2765838
lamda3：12 2.185089969 1.558979624 2.53957
总数：13 9.5605307091 8.866356107 8.899115 8.90
python
Martin Hope
user24758287
Asked: 2024-11-25 12:28:19 +0800 CST
  • 8

我想要执行以下操作：

输入：

df = pl.DataFrame({
    "a": [1,15,None,20,None]
})

输出：

df = pl.DataFrame({
    "a": [1,15,None,20,None],
    "b": [0,14,None,5,None]
})

也就是说，来自：

一个
1
15
没有任何
20
没有任何

到：

一个 乙
1 0
15 14
没有任何 没有任何
20 5
没有任何 没有任何

那么，它的作用是：

  1. 如果“A”的值为空，则 B（输出列）的值也为空
  2. 如果“A”有某个值，请检索“A”中的最后一个非空值，然后用前一个非空值减去“A”中的当前值

我想在 python 的 polars dataframe 库中执行此操作，但似乎找不到解决方案。

我尝试过以下问题：

如何在 Polars 中从一列中选择最后一个非空值并从同一行的另一列中选择值？

但不幸的是，这并不能回答原始问题，因为问题对整个列进行聚合，然后取该列的最后一个值。

我想要做的不是聚合整个列，而是简单地用先前的非空值减去当前值。

我也尝试过使用滚动：

df = df.with_row_index().rolling(
    index_column = 'index',
    period = '???i').agg(pl.col("A").last())

但是，当然，这是行不通的，因为无法确定空值的出现（即它不是周期性的，所以我不知道当前条目之前有多少个索引在“A”中包含非空值）。

有人知道怎么做吗？

谢谢！

python
Martin Hope
Josh
Asked: 2024-11-25 10:55:38 +0800 CST
  • 8

我继承了一些执行以下步骤的代码：

  1. 从压缩数据的字节数组开始，对其进行流式传输和解压缩
  2. 将其反序列化为对象列表
  3. 添加至列表
  4. 序列化列表
  5. 将数据重新压缩为字节数组
private static readonly RecyclableMemoryStreamManager MemoryStreamManager = new RecyclableMemoryStreamManager();

static async Task Main(string[] args)
{
    using (FileStream fileStream = new FileStream("C:\\data.txt", FileMode.Open, FileAccess.Read))
    {
        var dataList = await DecompressData(fileStream);
        dataList.Add(new MyObject { });
        using(var stream = MemoryStreamManager.GetStream())
        {
            await JsonSerializer.SerializeAsync(stream, dataList);
            stream.Position = 0;
            var b = await CompressData(stream);
        }
    }

    Console.WriteLine("All done");
}

private static async Task<List<SipTraceRecord>> DecompressData(Stream data)
{
    using (var resultStream = MemoryStreamManager.GetStream())
    {
        GZipStream gzip = new GZipStream(data, CompressionMode.Decompress);

        List<SipTraceRecord> recordsList = await JsonSerializer.DeserializeAsync<List<MyObject>>(gzip);
        return recordsList;
    }
}

private static async Task<byte[]> CompressData(Stream data)
{
    byte[] compressedData;
    using (var ms = MemoryStreamManager.GetStream())
    {
        using (GZipStream gzip = new GZipStream(ms, CompressionMode.Compress))
        {
            data.CopyTo(gzip);
            compressedData = ms.GetBuffer();
        }

    }

    return compressedData;
}

这与代码开始时有很大不同，我只是试图尽可能地优化内存。测试输入文件为 600Kb，解压后为 22Mb，之前它使用 100Mb 的内存。现在内存已降至 90Mb。内存使用率高的区域仍然存在，例如await JsonSerializer.SerializeAsync(stream, dataList);使用 10Mb 将数据写入流。这是否可以像在其他方向上一样进行优化，其中没有字节数组，只是根据需要进行流式传输？

这data.CopyTo(gzip);也是重复的数据，但此时数据已被压缩，因此仅使用<1Mb

c#
Martin Hope
oflahero
Asked: 2024-11-23 10:19:41 +0800 CST
  • 8

给定一个我正在测试的简单类型，比如

interface IMyRepo
{
  MyObj GetBy(Expression<Func<MyObj, bool> predicate);
}

因此标准模拟设置工作正常：

_repoMock.Setup(x => x.GetBy(y => y.Prop=="A")).Returns(myObjInstance);

例如，它匹配：_repo.GetBy(x => x.Prop=="A")

但是，如果我有一个辅助方法用于我的设置：_repoMock.Setup(Helpers.GenerateGetByMock<IMyRepo, MyObj>(y => y.Prop=="A"));

在哪里

Expression<Func<T, R>> GenerateGetByMock<T, R>(Expression<Func<R,bool>> pred) where T : IMyRepo where R : class
{
  return x => x.GetBy(pred);
}

这在测试中不_repo.GetBy(x => x.Prop=="A")匹配！

生成的表达式有什么不同？为什么我必须使用显式内联版本？有没有办法使用辅助方法？

编辑：这是带有内联版本的模拟表达式： 在此处输入图片描述

与辅助方法相比：

在此处输入图片描述

c#
Martin Hope
Sharif
Asked: 2024-11-22 12:46:13 +0800 CST
  • 8

我有这样的小事 -

# A tibble: 11 × 1
   messycol                   
   <chr>                      
 1 ""                         
 2 ""                         
 3 ""                         
 4 ""                         
 5 ""                         
 6 ""                         
 7 "|15|16|32|33|36|39|40|41|"
 8 "|15|16|32|39|"            
 9 "|10|29|32|38|39|40|"      
10 "|32|39|"                  
11 ""

输出dput()在这里 -

structure(list(messycol = structure(c("", "", "", "", "", "", 
"|15|16|32|33|36|39|40|41|", "|15|16|32|39|", "|10|29|32|38|39|40|", 
"|32|39|", ""), label = "Noteffectiveaccountingrule reason keys", format.sas = "$")), row.names = c(NA, 
-11L), class = c("tbl_df", "tbl", "data.frame"))

我想创建一个虚拟变量，如下所示messycol- 如果messycol包含 15 或 16，则为 1，否则为 0。请注意，中的空白值messycol应保持原样 -" "

所以，我的预期输出是这样的 -

# A tibble: 11 × 2
   messycol                         DUMMY                 
   <chr>                      
 1 ""                               ""                      
 2 ""                               ""                          
 3 ""                               ""                           
 4 ""                               ""                          
 5 ""                               ""                         
 6 ""                               ""                         
 7 "|15|16|32|33|36|39|40|41|"       1
 8 "|15|16|32|39|"                   1     
 9 "|10|29|32|38|39|40|"             0    
10 "|32|39|"                         0              
11 ""                               ""
Martin Hope
sds
Asked: 2024-11-22 04:51:27 +0800 CST
  • 8

可以理解且预期（tz-aware）：

import datetime
import numpy as np
import pandas as pd

aware = pd.DatetimeIndex(["2024-11-21", "2024-11-21 12:00"], tz="UTC")
eod = datetime.datetime.combine(aware[-1].date(), datetime.time.max, aware.tz)
aware, eod, np.concat([aware, [eod]])

返回

(DatetimeIndex(['2024-11-21 00:00:00+00:00', '2024-11-21 12:00:00+00:00'],
               dtype='datetime64[ns, UTC]', freq=None),
 datetime.datetime(2024, 11, 21, 23, 59, 59, 999999,
                   tzinfo=datetime.timezone.utc),
 array([Timestamp('2024-11-21 00:00:00+0000', tz='UTC'),
        Timestamp('2024-11-21 12:00:00+0000', tz='UTC'),
        datetime.datetime(2024, 11, 21, 23, 59, 59, 999999,
                          tzinfo=datetime.timezone.utc)],
       dtype=object))

注意返回值中的时间戳（和） 。datetimenp.concat

意外(tz-naive)：

naive = pd.DatetimeIndex(["2024-11-21", "2024-11-21 12:00"])
eod = datetime.datetime.combine(naive[-1].date(), datetime.time.max, aware.tz)
naive, eod, np.concat([naive, [eod]])

返回

(DatetimeIndex(['2024-11-21 00:00:00', '2024-11-21 12:00:00'],
               dtype='datetime64[ns]', freq=None),
 datetime.datetime(2024, 11, 21, 23, 59, 59, 999999),
 array([1732147200000000000, 1732190400000000000,
        datetime.datetime(2024, 11, 21, 23, 59, 59, 999999)], dtype=object))

注意 的返回值中的整数（和） 。datetimenp.concat

  1. 为什么我在连接数组中针对 tz-naive 索引获取整数？
  2. 我该如何避免这种情况？即，如何将 EOD 附加到 tz-naive DatetimeIndex？

PS：有趣的是，在numpy级别上索引是相同的：

np.testing.assert_array_equal(aware.values, naive.values)
python
上一页
下一页