标签: optimization

我有一个高性能的关键代码部分，需要访问结构的多个字段。将结构本身分配给变量，或使用指针获取结构的成员是否更快，例如

struct A* = A_arr + n;
int a = A->t - A->s;

对比

struct A = A_arr[n];
int a = A.t - A.s;

谢谢您的帮助！

正整数 N 内的二进制间隙是在 N 的二进制表示中两端被 1 包围的连续零的任何最大序列。

例如，数字 9 的二进制表示为 1001，并且包含长度为 2 的二进制间隙。数字 529 的二进制表示为 1000010001，并且包含两个二进制间隙：长度为 4 的一个和长度为 3 的一个。数字 20 的二进制表示为 10100，并且包含一个长度为 1 的二进制间隙。数字 15 具有二进制表示形式 1111，并且没有二进制间隙。

写一个函数：

int 解决方案（int N）；给定一个正整数 N，返回其最长二进制间隙的长度。如果 N 不包含二进制间隙，则该函数应返回 0。

例如，给定 N = 1041，该函数应返回 5，因为 N 的二进制表示为 10000010001，因此其最长的二进制间隙长度为 5。

public int solution(int n) {
        // write your code in Java SE 8
        String binaryRep = Integer.toBinaryString(n);
        System.out.println("Binary Representation of " + n + " = " + binaryRep);
        List<String> strList = new ArrayList<String>();
        int …

我的代码中有一个4D矩阵用于解决数学问题

int**** Sads = new int***[inputImage->HeightLines];
for (size_t i = 0; i < inputImage->HeightLines; i++)
{
    Sads[i] = new int**[inputImage->WidthColumns];
    for (size_t j = 0; j < inputImage->WidthColumns; j++)
    {
        Sads[i][j] = new int*[W_SIZE];
        for (size_t k = 0; k < W_SIZE; k++)
         {
              Sads[i][j][k] = new int[W_SIZE];
         }
    }
 }

//do something with Sads...

for (int i = 0; i < inputImage->HeightLines; i++)
        {
            int*** tempI = Sads[i];
            for (int j = 0; j < inputImage->WidthColumns; j++)
            {
                int** …

遵循两个代码片段哪个更快？为什么？

在for语句外声明循环索引变量:

size_t i = 0;
for (i = 0; i < 10; i++) 
{

}

和

for语句中声明的循环索引变量:

for (size_t i = 0; i < 10; i++) 
{

}

例如,在显微镜下查看代码时,第一个代码块是否比第二个代码块使用更多的计算时间？

代码块1:

method1() {
do something;
call method2;
}
method2() {
do something simple like assign a variable value;
}

代码块2:

method1(){
do something;
do something simple like assign a variable value;
}

非常简单,但是我想看看这里是否有人知道考虑这一点的价值是什么(例如,优化程序以获得最短的计算时间).

作为一个例子,我了解到电路中的门具有有限的"Delta延迟",在该延迟中可以加起来看到在考虑设计中的时钟速度时电路将具有的最大延迟.Java有类似Delta延迟的东西吗？

我有一个优化for循环的任务,所以编译器编译运行得更快的代码.目标是使代码在5秒或更短的时间内运行,原始运行时间约为23秒.原始代码如下所示:

#include <stdio.h>
#include <stdlib.h>

#define N_TIMES     600000
#define ARRAY_SIZE   10000

int main(void)
{
    double  *array = calloc(ARRAY_SIZE, sizeof(double));
    double  sum = 0;
    int     i;

    printf("CS201 - Asgmt 4 - I. Forgot\n");

    for (i = 0; i < N_TIMES; i++) {

        int     j;

        for (j = 0; j < ARRAY_SIZE; j++) {
            sum += array[j];
            }

        }

    return 0;
}

我的第一个想法是在内部for循环上进行循环展开,使其下降到5.7秒,并且该循环看起来像这样:

 for (j = 0; j < ARRAY_SIZE - 11; j+= 12) {
            sum = sum + (array[j] + array[j+1] …

我的代码提取是

if (num == 0) {
    cout << 1;
    cout << 2;
}
else if (num == 1) {
    cout << 0;
    cout << 2;
}
else if (num == 2) {
    cout << 0;
    cout << 1;
}

其中0 <= num <= 2.

我在问,因为这些cout << ...陈述将被转换成更大的东西,但(几乎)彼此相同.

*我的意思是优化为'美化'代码(例如删除5个重复的cout语句).

^{我没有在问题中加入"美化",因为它在SO问题中听起来很奇怪.}

问题示例：

计算123 * 456是否比计算123456 * 7890快？还是相同的速度？

我想知道32位无符号整数，但是我不会忽略其他类型（64位，有符号，浮点型等）的答案。如果不同，则有什么不同？这些位是否为0/1？

编辑：如果有所不同，我应该澄清一下，我指的是任何数字（两个低于100的随机数与两个高于1000的随机数）

I need to know is there a better / shorter way to write following code in c++. (while going through the main if-else (step by step), additional check for variable 'y' will be added)

int x = 5, y = 4;        

if(x == 1){
  if(y == 1)
      printf("ok");
  else
      printf("not ok");
}
else if(x == 2){
  if((y == 1) || (y == 2))
      printf("ok");
  else
      printf("not ok");
}
else{
  if((y == 1) || (y == 2) || (y == 3)) …

In 最近使用 CP Optimizer（CPLEX 约束编程求解器）解决了几个调度项目，并且能够使用它获得一些非常好的结果。但是，与Cplex相比，CP Optimizer对我来说仍然是一个大黑箱。通常可以用不同的方式来表述一个问题，而小的变化可能会导致性能的巨大差异。在我看来，缺乏文档和示例，这使得它很难使用。也没有所有约束编程求解器共享的标准化约束集，甚至没有一种导出格式可以让我解决 CP Optimizer 和替代求解器（Xpress Kalis 或像 Gecode 这样的开源替代方案）陈述的问题， 例如）。

虽然我知道商业 MIP 求解器比开源替代方案强大得多，但我还没有看到任何比较不同约束编程求解器的研究。

我想知道其他约束编程求解器与 CP Optimizer 相比如何。我对调度应用程序特别感兴趣，CP Optimizer 对此具有一组特殊的变量（间隔和序列）和许多有用的约束（优先级、无重叠等）。我不介意使用整数变量代替区间变量并以更复杂的方式制定约束，但我想知道是否有任何开源约束编程求解器可以与商业求解器竞争。