1.02 main.cpp研究

最新推荐文章于 2024-06-17 09:23:46 发布
转载 最新推荐文章于 2024-06-17 09:23:46 发布 · 51 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/nfking/p/5586117.html

本文探讨了Cocos2d-x中单例模式的应用，包括静态类成员函数的使用、单例模式实现机制及其在游戏开发中的具体应用案例。此外还涉及多态、AppDelegate接口等内容。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.02 main.cpp研究 


   
  1.  // create the application instance
  2.  AppDelegate app;
  3.  CCEGLView* eglView = CCEGLView::sharedOpenGLView();
  4.  eglView->setViewName("Fei");
  5.  eglView->setFrameSize(480, 320);
  6.  return CCApplication::sharedApplication()->run();

  

  

   

  

 

 

  一、静态类成员函数
 

 

      CCEGLView::sharedOpenGLView
  

 

 

      CCApplication::sharedApplication
  

 

 

      凡是以 share 开头的这种方式都是类成员静态函数
  

 

 

  

 

 

  二、
  单例模式
 

 

      单例模式：我进来一次之后，这个指针（每个里面都有一个静态指针的），如果这个静态指针为空的话我就直接创建，不为空我就直接返回。保证只有一个单例
  

 

 

  

 

 

  三、多态
 

 

      子类 overwrite 了父类的虚函数
  

 

 

      要有子类对象的指针
  

 

 

      子类指针赋给父类，父类指针调用虚接口
  

 

 

  

 

 

  四、this 水好深
 

 

  

 

 

  五、AppDelegate.h 三大接口
 

 

      virtual bool applicationDidFinishLaunching(); //游戏开始接口
  

 

 

      virtual void applicationDidEnterBackground(); //Home 键接口
  

 

 

      virtual void applicationWillEnterForeground(); //
  来
  电话时接电话打断的接口
 

 

  

 

 

  六、AppDelegate、CCApplication、CCApplicationProtocol 关系
 

 

      AppDelegate 和 CCApplicationProtocol 永远不变
  

 

 

      而 CCApplication 却放着跨平台的东西，变的永远是 CCApplication
  

 

 

  

 

 

      设计思想：最上层和最下层永远不变，而中间可以一直变着适应不同的东西，这可能也是代理模式的初衷
  

 

 

  

 

 

  

 

 

 

 
 

 


 

转载于:https://www.cnblogs.com/nfking/p/5586117.html

                

        




    

    
  



    



                



	

		

			

				
					
C语言编译错误新手解决方法,C语言编译器的错误信息

				
			

			

				

					weixin_33737110的博客
				

				

					05-19
					
					2260
					
				

			

		

		

			
				
该楼层疑似违规已被系统折叠隐藏此楼查看此楼Notavalidexpressionformattype不合法的表达式格式Notanallowedtype不允许使用的类型Numericconstanttoolarge数值常太大Outofmemory内存不够用Parameter'xxx'isneverused能数xxx没有用到Pointerrequired...

			
		

	



                

            
              



	

		

			

				
					
MiniCPM: 揭示端侧大语言模型的无限潜力 github页面

				
			

			

				

					强化学习曾小健
				

				

					07-12
					
					1671
					
				

			

		

		

			
				
加入我们的和MiniCPM 是面壁智能与清华大学自然语言处理实验室共同开源的系列端侧大模型，主体语言模型 MiniCPM-2B 仅有24亿（2.4B）的非词嵌入参数量,总计2.7B参数量。Mistral-7B 表现相近MTBench 上也超越了 Llama2-70B-Chat、Vicuna-33B、Mistral-7B-Instruct-v0.1、Zephyr-7B-alpha领先的 OCR 能力场景文字识别能力上接近 Gemini Pro流式输出速度略高于人类说话速度。

			
		

	



              


  
              

                


	

		

			

				
					
[C/C++] ccpuid：CPUID信息模块 V1.02版，支持Mac OS X，支持纯C，增加CPUF常数

				
			

			

				

					weixin_30301183的博客
				

				

					09-29
					
					2676
					
				

			

		

		

			
				
新版本——http://www.cnblogs.com/zyl910/archive/2012/10/13/ccpuid_v103.html

作者：zyl910。
　　之前的ccpuid V1.01版只支持Windows和Linux平台。现在的V1.02版增加对Mac OS X平台的支持，还做了这些改进——支持纯C、增加CPUF常数、x86平台判断。
一、更新说明
1.1 支持Mac...

			
		

	





	

		

			

				
					
20160127.CCPP体系详解(0006天)

				
			

			

				

					尹成的技术博客
				

				

					02-16
					
					1871
					
				

			

		

		

			
				
程序片段(01):msg.c 
内容概要:线程概念#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
#include <process.h>//线程函数头文件声明//01.编程当中所涉及到的重要概念:
//  进程-->线程-->模块儿-->动态库(Dll)-->静态库Lib)
//02.此单线程程序剖析:
//  1.main0

			
		

	



		

			
		



	

		

			

				
					
java笔记1.02

				
			

			

				

					qq_46664420的博客
				

				

					05-06
					
					310
					
				

			

		

		

			
				
1.  java中class类型的赋值，被视作是引用
如下定义了a类型a1，a2，a2=a1;
并不只是把a1的值赋给a2，而是引用，其中的任何一个变化另一个都会随之变化
public class test01 {
    public static void main(String[] args) {
        a a1 = new a();

        a a2 = new a();
        a2 = a1; // 注意这一步

        a1.b = 20;
        

			
		

	





	

		

			

				
					
Qt 工具链及项目的构建、编译过程

				
			

			

				

					置心一处，便无事不办
				

				

					06-17
					
					1659
					
				

			

		

		

			
				
Qt 不是凭空产生的，它是基于现有工具链打造而成的，它所使用的编译器、链接器、调试器等都不是自己的，Qt 官方只是开发了上层工具。下面我们介绍 Qt 使用到的工具链。Qt 安装后会出现Qt CreatorDesignerAssistantLinguist等工具，他们有什么用呢？观察 Qt 项目编译后的输出目录，会发现有那么几个特定的文件：moc_xxx.cpp、moc_xxx.h、qrc_xxx.cpp、qrc_xxx.h、ui_xxx.h。

			
		

	





	

		

			

				
					
1.02 输出第二个整数

				
			

			

				

					chuyi6142的博客
				

				

					01-30
					
					266
					
				

			

		

		

			
				
描述 
输入三个整数，把第二个输入的整数输出。 
输入 
只有一行，共三个整数，整数之间由一个空格分隔。整数是32位有符号整数。 
输出 
只有一行，一个整数，即输入的第二个整数。 
样例输入 
123 456 789 
样例输出 
456 
——————————————————叫我分割线大人...

			
		

	





	

		

			

				
					
Ceres入门

				
			

			

				

					weixin_36976685的博客
				

				

					07-25
					
					916
					
				

			

		

		

			
				
写的很好，转载一下 原文链接：https://www.jianshu.com/p/e5b03cf22c80

Ceres solver 是谷歌开发的一款用于非线性优化的库，在谷歌的开源激光雷达slam项目cartographer中被大量使用。Ceres官网上的文档非常详细地介绍了其具体使用方法，相比于另外一个在slam中被广泛使用的图优化库G2O，ceres的文档可谓相当丰富详细（没有对比就没有伤...

			
		

	





	

		

			

				
					
足够惊艳，使用Alpaca-Lora基于LLaMA(7B)二十分钟完成微调，效果比肩斯坦福羊驼

				
			

			

				

					吃果冻不吐果冻皮
				

				

					04-10
					
					6692
					
				

			

		

		

			
				
从上面可以看到，在一台8卡的A800服务器上面，基于Alpaca-Lora针对指令数据大概20分钟左右即可完成参数高效微调，相对于斯坦福羊驼训练速度显著提升。参考文档LLaMA：斯坦福-羊驼。

			
		

	





	

		

			

				
					
Ubuntu下源码编译VirtualBox六 —— 源码编译（5）

				
			

			

				

					phmatthaus的专栏
				

				

					01-20
					
					2478
					
				

			

		

		

			
				
Ubuntu下源码编译VirtualBox六 —— 源码编译（5）

			
		

	





	

		

			

				
					
c语言 之 猜数字 源程序

				
			

			

				

					09-28
				

			

		

		

			
				
首先，`guessNum 1.02.cpp`和`guessNum 1.01.cpp`是两个不同版本的源代码文件，可能代表了作者在开发过程中的迭代改进。`.cpp`扩展名表明这些文件是用C++编写的，尽管C++是从C语言发展而来，但它们之间存在一些差异...

			
		

	





	

		

			

				
					
出现问题迭代 1 | 总损失: 6.72196 | 距离损失: 10.1859 | 面积损失: 0.288881
0x00007FFE5A118508 (torch_cpu.dll)处(位于 test.exe 中)引发的异常: 0xC000008E: Floating-point division by zero (参数: 0x0000000000000000, 0x0000000000001924)。
“test.exe”(Win32): 已加载“C:\Windows\System32\duser.dll”。
“test.exe”(Win32): 已加载“C:\Windows\System32\xmllite.dll”。
“test.exe”(Win32): 已加载“C:\Windows\System32\atlthunk.dll”。
“test.exe”(Win32): 已卸载“C:\Windows\System32\xmllite.dll”
0x00007FFF5CE8933A (KernelBase.dll)处(位于 test.exe 中)引发的异常: 0x8001010D: 因为应用程序正在发送一个输入同步呼叫，所以无法执行传出的呼叫。。
“test.exe”(Win32): 已加载“C:\Windows\System32\OneCoreCommonProxyStub.dll”。
0x00007FFF5CE8933A 处(位于 test.exe 中)引发的异常: Microsoft C++ 异常: wil::ResultException，位于内存位置 0x000000EDA68FDF50 处。
0x00007FFF5CE8933A 处(位于 test.exe 中)引发的异常: Microsoft C++ 异常: [rethrow]，位于内存位置 0x0000000000000000 处。
线程 33260 已退出，返回值为 0 (0x0)。
0x00007FFF5CE8933A 处(位于 test.exe 中)引发的异常: Microsoft C++ 异常: wil::ResultException，位于内存位置 0x000000EDA68FE2B0 处。
0x00007FFF5CE8933A 处(位于 test.exe 中)引发的异常: Microsoft C++ 异常: [rethrow]，位于内存位置 0x0000000000000000 处。
0x00007FFF5CE8933A 处(位于 test.exe 中)引发的异常: Microsoft C++ 异常: wil::ResultException，位于内存位置 0x000000EDA68FE300 处。
0x00007FFF5CE8933A 处(位于 test.exe 中)引发的异常: Microsoft C++ 异常: [rethrow]，位于内存位置 0x0000000000000000 处。
0x00007FFF5CE8933A 处(位于 test.exe 中)引发的异常: Microsoft C++ 异常: wil::ResultException，位于内存位置 0x000000EDA68FDF50 处。
0x00007FFF5CE8933A 处(位于 test.exe 中)引发的异常: Microsoft C++ 异常: [rethrow]，位于内存位置 0x0000000000000000 处。
0x00007FFF5CE8933A 处(位于 test.exe 中)引发的异常: Microsoft C++ 异常: wil::ResultException，位于内存位置 0x000000EDA68FE2B0 处。
0x00007FFF5CE8933A 处(位于 test.exe 中)引发的异常: Microsoft C++ 异常: [rethrow]，位于内存位置 0x0000000000000000 处。
0x00007FFF5CE8933A 处(位于 test.exe 中)引发的异常: Microsoft C++ 异常: wil::ResultException，位于内存位置 0x000000EDA68FE300 处。
0x00007FFF5CE8933A 处(位于 test.exe 中)引发的异常: Microsoft C++ 异常: [rethrow]，位于内存位置 0x0000000000000000 处。
线程 36532 已退出，返回值为 0 (0x0)。
线程 1208 已退出，返回值为 0 (0x0)。
线程 36320 已退出，返回值为 0 (0x0)。
线程 22984 已退出，返回值为 0 (0x0)。
线程 4384 已退出，返回值为 0 (0x0)。
线程 17576 已退出，返回值为 0 (0x0)。
线程 14288 已退出，返回值为 0 (0x0)。
线程 35492 已退出，返回值为 0 (0x0)。
线程 22860 已退出，返回值为 0 (0x0)。
0x00007FFF5CE8933A 处(位于 test.exe 中)引发的异常: Microsoft C++ 异常: wil::ResultException，位于内存位置 0x000000EDA68FE330 处。
0x00007FFF5CE8933A 处(位于 test.exe 中)引发的异常: Microsoft C++ 异常: [rethrow]，位于内存位置 0x0000000000000000 处。
0x00007FFF5CE8933A 处(位于 test.exe 中)引发的异常: Microsoft C++ 异常: wil::ResultException，位于内存位置 0x000000EDA68FE3A0 处。
0x00007FFF5CE8933A 处(位于 test.exe 中)引发的异常: Microsoft C++ 异常: [rethrow]，位于内存位置 0x0000000000000000 处。
0x00007FFF5CE8933A 处(位于 test.exe 中)引发的异常: Microsoft C++ 异常: wil::ResultException，位于内存位置 0x000000EDA68FE330 处。
0x00007FFF5CE8933A 处(位于 test.exe 中)引发的异常: Microsoft C++ 异常: [rethrow]，位于内存位置 0x0000000000000000 处。
0x00007FFF5CE8933A 处(位于 test.exe 中)引发的异常: Microsoft C++ 异常: wil::ResultException，位于内存位置 0x000000EDA68FE3A0 处。
0x00007FFF5CE8933A 处(位于 test.exe 中)引发的异常: Microsoft C++ 异常: [rethrow]，位于内存位置 0x0000000000000000 处。
0x00007FFF5CE8933A 处(位于 test.exe 中)引发的异常: Microsoft C++ 异常: wil::ResultException，位于内存位置 0x000000EDA68FE330 处。
0x00007FFF5CE8933A 处(位于 test.exe 中)引发的异常: Microsoft C++ 异常: [rethrow]，位于内存位置 0x0000000000000000 处。
0x00007FFF5CE8933A 处(位于 test.exe 中)引发的异常: Microsoft C++ 异常: wil::ResultException，位于内存位置 0x000000EDA68FE3A0 处。
0x00007FFF5CE8933A 处(位于 test.exe 中)引发的异常: Microsoft C++ 异常: [rethrow]，位于内存位置 0x0000000000000000 处。
线程 30132 已退出，返回值为 0 (0x0)。
线程 27048 已退出，返回值为 0 (0x0)。
线程 27212 已退出，返回值为 0 (0x0)。
线程 33764 已退出，返回值为 0 (0x0)。
线程 35108 已退出，返回值为 0 (0x0)。
线程 12392 已退出，返回值为 0 (0x0)。
#define PARTICLESWARMMETHOD_EXPORTS  // 定义导出宏
#include "particleSwarmMethod.h"

torch::Tensor distance_point_to_segment(const torch::Tensor& P, const torch::Tensor& A, const torch::Tensor& B)
{
    auto AP = P - A;
    auto AB = B - A;
    auto ab_sq = AB.pow(2).sum();

    if (ab_sq.item<float>() == 0) 
    {
        return AP.norm(2, 1);
    }

    auto t = torch::mv(AP, AB.squeeze()) / ab_sq;
    t = torch::clamp(t, 0.0, 1.0);
    auto proj = A + t.unsqueeze(1) * AB;
    return (P - proj).norm(2, 1);
}

std::vector<std::vector<float>> particle(const std::vector<float>& wy, const std::vector<float>& zh)
{
    std::vector<std::vector<float>> particles;//六边形初始化

    auto wymax = *std::max_element(wy.begin(), wy.end());
    auto wymin = *std::min_element(wy.begin(), wy.end());
    auto zhmax = *std::max_element(zh.begin(), zh.end());
    auto zhmin = *std::min_element(zh.begin(), zh.end());

    particles.push_back({ wymin, zhmax });
    particles.push_back({ wymax, zhmax });
    particles.push_back({ wymax, (zhmax - zhmin) * 0.5f + zhmin });
    particles.push_back({ (wymax - wymin) * 0.5f + wymin, (zhmax - zhmin) * 0.5f + zhmin });
    particles.push_back({ (wymax - wymin) * 0.5f + wymin, zhmin });
    particles.push_back({ wymin, zhmin });

    return particles;
}

// 应用约束
torch::Tensor apply_constraints(torch::Tensor vertices)
{
    torch::NoGradGuard no_grad;  // 临时禁用梯度计算

    // 边界约束
    vertices.data() = torch::clamp(vertices, -0.05, 1.02);

    auto min_val = torch::tensor(0.2, vertices.options());
    auto max_val = vertices.index({ 1, 0 }) * 1.1;

    vertices.index_put_({ 2, 0 }, torch::clamp(vertices.index({ 2, 0 }), min_val, max_val));

    vertices.index_put_({ 2, 1 }, torch::clamp(vertices.index({ 2, 1 }), 0.2, 1.02));

    vertices.index_put_({ 3, 0 }, torch::clamp(vertices.index({ 3, 0 }),
        vertices.index({ 4, 0 }),
        vertices.index({ 2, 0 }) * 1.1));

    vertices.index_put_({ 3, 1 }, torch::clamp(vertices.index({ 3, 1 }),
        vertices.index({ 4, 1 }) * 1.1,
        vertices.index({ 2, 1 })));

    vertices.index_put_({ 4, 0 }, torch::clamp(vertices.index({ 4, 0 }),
        vertices.index({ 5, 0 }) * 1.1,
        vertices.index({ 3, 0 })));

    vertices.index_put_({ 4, 1 }, torch::clamp(vertices.index({ 4, 1 }),
        torch::nullopt,
        vertices.index({ 5, 1 }) + 0.1));

    return vertices;
}


// 计算损失函数
std::tuple<torch::Tensor, torch::Tensor, torch::Tensor>
calculate_gradient_descent_loss(const torch::Tensor& vertices,
    const torch::Tensor& points,
    const torch::Tensor& target_area,
    float lambda1) 
{
    // 计算六边形面积
    auto shifted_vertices = torch::roll(vertices, -1, 0);
    auto x = vertices.index({ torch::indexing::Slice(), 0 });
    auto y = vertices.index({ torch::indexing::Slice(), 1 });
    auto x_shifted = shifted_vertices.index({ torch::indexing::Slice(), 0 });
    auto y_shifted = shifted_vertices.index({ torch::indexing::Slice(), 1 });

    auto area = 0.5 * torch::abs(torch::sum(x * y_shifted - y * x_shifted));

    // 计算所有边到数据点的距离
    std::vector<std::pair<int, int>> edges;
    for (int i = 0; i < 6; ++i) 
    {
        edges.emplace_back(i, (i + 1) % 6); // 添加边 (i, (i+1)%6)
    }
    std::vector<torch::Tensor> dists;

    for (const auto& edge : edges) {
        auto A = vertices[edge.first].unsqueeze(0);  // [1, 2]
        auto B = vertices[edge.second].unsqueeze(0); // [1, 2]
        auto dist = distance_point_to_segment(points, A, B);
        dists.push_back(dist);
    }

    auto dist_matrix = torch::stack(dists, 1);
    auto min_dists = std::get<0>(torch::min(dist_matrix, 1));
    auto distance_loss = torch::sum(min_dists);

    // 计算面积损失
    auto area_loss = torch::abs(area - target_area);

    // 总损失
    auto total_loss = (1 - lambda1) * area_loss + lambda1 * distance_loss;

    return { total_loss, distance_loss, area_loss };
}

extern "C" PARTICLESWARMMETHOD_API int* opening_closing_point_recognition(
    const float* wy, int wySize,
    const float* zh, int zhSize,
    int iterations,
    bool print1,
    float lambda1,
    int* resultSize
 ) {
    // 输出所有输入信息
    std::cout << "Opening_closing_point_recognition 函数的输入信息：" << std::endl;
    std::cout << "wy 数组内容：";
    for (int i = 0; i < wySize; ++i) {
        std::cout << wy[i];
        if (i < wySize - 1) {
            std::cout << ", ";
        }
    }
    std::cout << std::endl;
    std::cout << "wy 数组大小: " << wySize << std::endl;

    std::cout << "zh 数组内容：";
    for (int i = 0; i < zhSize; ++i) {
        std::cout << zh[i];
        if (i < zhSize - 1) {
            std::cout << ", ";
        }
    }
    std::cout << std::endl;
    std::cout << "zh 数组大小: " << zhSize << std::endl;

    std::cout << "迭代次数: " << iterations << std::endl;
    std::cout << "是否打印信息: " << (print1 ? "是" : "否") << std::endl;
    std::cout << "权重系数 lambda1: " << lambda1 << std::endl;
    // 数据归一化
    auto wmin = *std::min_element(wy, wy + wySize);
    auto wmax = *std::max_element(wy, wy + wySize);
    auto zmin = *std::min_element(zh, zh + zhSize);
    auto zmax = *std::max_element(zh, zh + zhSize);

    std::vector<float> wy_nored(wySize), zh_nored(zhSize);
    for (int i = 0; i < wySize; ++i) {
        wy_nored[i] = (wy[i] - wmin) / (wmax - wmin);
    }
    for (int i = 0; i < zhSize; ++i) {
        zh_nored[i] = (zh[i] - zmin) / (zmax - zmin);
    }

    std::vector<float> low_before = { *std::min_element(wy_nored.begin(), wy_nored.end()) - 0.1f,
        *std::min_element(zh_nored.begin(), zh_nored.end()) - 0.1f };
    std::vector<float> up_before = { *std::max_element(wy_nored.begin(), wy_nored.end()) * 1.1f,
        *std::max_element(zh_nored.begin(), zh_nored.end()) * 1.1f };

    std::vector<float> low, up;
    for (int i = 0; i < 6; ++i) 
    {
        low.insert(low.end(), low_before.begin(), low_before.end());
        up.insert(up.end(), up_before.begin(), up_before.end());
    }

    // 初始化六边形
    std::vector<std::vector<float>> polygon = particle(wy_nored, zh_nored);

    // 将 polygon (vector<vector<float>>) 转换为 Tensor
    std::vector<float> flattened;
    for (const auto& point : polygon) 
    {
        flattened.insert(flattened.end(), point.begin(), point.end());
    }
    torch::Tensor vertices = torch::tensor(flattened, torch::dtype(torch::kFloat32))
        .view({ -1, 2 })
        .requires_grad_(true);


    // 创建优化器
    auto optimizer = torch::optim::AdamW({ vertices }, torch::optim::AdamWOptions(0.008));
    //auto scheduler = torch::optim::LRScheduler(optimizer, 500);
    
    // 准备数据点
    std::vector<torch::Tensor> point_tensors;
    for (size_t i = 0; i < wy_nored.size(); ++i) 
    {
        point_tensors.push_back(torch::tensor({ wy_nored[i], zh_nored[i] }));
    }
    auto points = torch::stack(point_tensors);
    std::cout << "vertices 张量的值:" << std::endl;
    auto vertices_accessor = points.accessor<float, 2>();
    for (int i = 0; i < points.size(0); ++i) {
        for (int j = 0; j < points.size(1); ++j) {
            std::cout << vertices_accessor[i][j] << " ";
        }
        std::cout << std::endl;
    }

    // 计算目标面积
    auto shifted_points = torch::roll(points, -1, 0);
    auto target_area = 0.5 * torch::abs(torch::sum(
        points.index({ torch::indexing::Slice(), 0 }) * shifted_points.index({ torch::indexing::Slice(), 1 }) -
        points.index({ torch::indexing::Slice(), 1 }) * shifted_points.index({ torch::indexing::Slice(), 0 })));

    // 优化循环
    for (int k = 0; k < iterations; ++k) {
        optimizer.zero_grad();

        auto loss = calculate_gradient_descent_loss(vertices, points, target_area, lambda1);
        //[total_loss, distance_loss, area_loss]

        torch::Tensor total_loss = std::get<0>(loss);  // 第一个元素
        torch::Tensor distance_loss = std::get<1>(loss);  // 第二个元素
        torch::Tensor area_loss = std::get<2>(loss);  // 第三个元素
        // 输出损失信息
        std::cout << "迭代 " << k + 1
            << " | 总损失: " << total_loss.item<float>()
            << " | 距离损失: " << distance_loss.item<float>()
            << " | 面积损失: " << area_loss.item<float>() << std::endl;

        try
        {
            total_loss.backward();
        }
        catch (const c10::Error& e) {
            std::cerr << "Caught c10::Error: " << e.what() << std::endl;
        }
        catch (const std::exception& e) {
            std::cerr << "Caught std::exception: " << e.what() << std::endl;
        }
        vertices = apply_constraints(vertices);
        optimizer.step();
        /*
        // 打印信息
        std::cout << "迭代次数 " << k + 1
            << ", 面积损失: " << area_loss.item<float>()
            << ", 距离损失: " << distance_loss.item<float>()
            << ", 总损失: " << total_loss.item<float>() << std::endl;
            */
    }

    // 找到最近点
    std::vector<int> vertex_indices = { 0, 1, 4, 5 };
    std::vector<std::vector<float>> closest_points;

    for (int idx : vertex_indices) {
        auto vertex = vertices.index({ idx }).unsqueeze(0);
        auto distances = torch::norm(points - vertex, 2, 1);
        auto closest_idx = torch::argmin(distances).item<int>();

        auto closest_point = points.index({ closest_idx });
        closest_points.push_back({
            closest_point.index({0}).item<float>(),
            closest_point.index({1}).item<float>()
            });
    }

    // 反归一化
    std::vector<std::vector<float>> closest_points_original;
    for (const auto& point : closest_points) {
        closest_points_original.push_back({
            point[0] * (wmax - wmin) + wmin,
            point[1] * (zmax - zmin) + zmin
            });
    }

    // 匹配原始数据点索引
    std::vector<int> matched_indices;
    for (const auto& point : closest_points_original) {
        for (int i = 0; i < wySize; i++) {
            if (round(point[0] * 100.0f) / 100.0f == round(wy[i] * 100.0f) / 100.0f &&
                round(point[1] * 100.0f) / 100.0f == round(zh[i] * 100.0f) / 100.0f) {
                matched_indices.push_back(i);
                break;
            }
        }
    }

    // 打印结果
    if (print1) {
        std::cout << "反归一化后的最近点坐标：" << std::endl;
        for (size_t i = 0; i < closest_points_original.size(); ++i) {
            std::cout << "顶点 " << vertex_indices[i] << " 最近点: ["
                << closest_points_original[i][0] << ", "
                << closest_points_original[i][1] << "]" << std::endl;
        }
    }

    *resultSize = static_cast<int>(matched_indices.size());

    // 动态分配结果数组
    int* output = new int[matched_indices.size()];
    std::copy(matched_indices.begin(), matched_indices.end(), output);

    return output;
}

extern "C" PARTICLESWARMMETHOD_API void free_int_array(int* arr) {
    delete[] arr;
}

				
			

			

				

					05-29
				

			

		

		

			
				
int main() {  // 初始化模型和优化器  auto model = std::make_shared(10, 1);  auto optimizer = torch::optim::SGD(model->parameters(), 0.01);   // 输入数据（显式指定浮点类型）  auto inputs = torch::randn...

			
		

	





	

		

			

				
					
基于https://github.com/dnwrnr/sgp4库，用c++编写一个卫星观测地面上某个点的时间窗

				
			

			

				

					07-02
				

			

		

		

			
				
 double apparent_elevation = elevation + 1.02 / tan((elevation + 10.3/(elevation+5.11)) * M_PI/180);  ```  3. **地形遮挡**：  - 需集成数字高程模型(DEM)数据  - 计算视线路径上的地形高度  4. *...

			
		

	





	

		

			

				
					
#include "core.h"
#include "ccc.h"
#include <cmath>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;

CCC::CCC():
m_iSYNInterval(CRUDP::m_iSYNInterval),
	m_dPktSndPeriod(1.0),
	m_dCWndSize(16.0),
	m_iBandwidth(),
	m_dMaxCWndSize(),
	m_iMSS(),
	m_iSndCurrSeqNo(),
	m_iRcvRate(),
	m_iRTT(),
	m_pcParam(NULL),
	m_iPSize(0),
	m_RUDP(),
	m_iACKPeriod(0),
	m_iACKInterval(0),
	m_bUserDefinedRTO(false),
	m_iRTO(-1),
	m_iRWSize(0),
	m_counter1(0),
	m_counter2(0),
	m_step(0.01),
	m_iRTTRef(0),
	m_bCongestion(false),
	m_bBeginCongestionCtrl1(false),
	m_bBeginCongestionCtrl2(false),
	m_bBeginCongestionCtrl3(false),
	m_ExpectBW(0),
	m_SP(100),

m_PerfInfo()
{
}

CCC::~CCC()
{
   delete [] m_pcParam;
}

void CCC::setACKTimer(int msINT)
{
   m_iACKPeriod = msINT > m_iSYNInterval ? m_iSYNInterval : msINT;
}

void CCC::setACKInterval(int pktINT)
{
   m_iACKInterval = pktINT;
}

void CCC::setRTO(int usRTO)
{
   m_bUserDefinedRTO = true;
   m_iRTO = usRTO;
}

void CCC::sendCustomMsg(CPacket& pkt) const
{
   CRUDP* u = CRUDP::getRUDPHandle(m_RUDP);

   if (NULL != u)
   {
      pkt.m_iID = u->m_PeerID;
      u->m_pSndQueue->sendto(u->m_pPeerAddr, pkt);
   }
}

const CPerfMon* CCC::getPerfInfo()
{
   try
   {
      CRUDP* u = CRUDP::getRUDPHandle(m_RUDP);
      if (NULL != u)
         u->sample(&m_PerfInfo, false);
   }
   catch (...)
   {
      return NULL;
   }

   return &m_PerfInfo;
}

void CCC::setMSS(int mss)
{
   m_iMSS = mss;
}

void CCC::setBandwidth(int bw)
{
   m_iBandwidth = bw;
}

void CCC::setSndCurrSeqNo(int32_t seqno)
{
   m_iSndCurrSeqNo = seqno;
}

void CCC::setRcvRate(int rcvrate)
{
   m_iRcvRate = rcvrate;
}

void CCC::setMaxCWndSize(int cwnd)
{
   m_dMaxCWndSize = cwnd;
}
void CCC::setRTTVar(int var)
{
	m_iRTTVar=var;
   
}
void CCC::setRTT(int rtt)
{
    m_iRTT = rtt;
	if(m_iRTTRef==0 && m_iRTT>0)
	{
		m_iRTTRef=m_iRTT;
	}
}
   void CCC::setPackets(uint64_t packets)
{
   m_Packets = packets;
}
void CCC::setMaxBW(uint64_t bw)
{
   m_MaxBW = bw;
}

void CCC::setSendRate(double sendrate)
{
	if(m_counter1>9)
		m_counter1=0;
	m_SendRateWindow[m_counter1]=sendrate;
}
void CCC::setFlowWindowSize(int FlowWindowSize)
{
	m_iFlowWindowSize=FlowWindowSize;
}
void CCC::setUserParam(const char* param, int size)
{
   delete [] m_pcParam;
   m_pcParam = new char[size];
   memcpy(m_pcParam, param, size);
   m_iPSize = size;
}

CRUDPCC::CRUDPCC():
m_iRCInterval(),
m_LastRCTime(),
m_LastDecTime(),
m_bSlowStart(),
m_iLastAck(),
m_bLoss(),
m_iLastDecSeq(),
m_dLastDecPeriod(),
m_iNAKCount(),
m_iDecRandom(),
m_iAvgNAKNum(),
m_iDecCount(),
m_factor(1.0)
{
}

void CRUDPCC::init()
{
   m_iRCInterval = m_iSYNInterval;
   m_LastRCTime = CTimer::getTime();
   setACKTimer(m_iRCInterval);

   m_bSlowStart = true;
   m_iLastAck = m_iSndCurrSeqNo;
   m_bLoss = false;
   m_iLastDecSeq = CSeqNo::decseq(m_iLastAck);
   m_dLastDecPeriod = 1;
   m_iAvgNAKNum = 0;
   m_iNAKCount = 0;
   m_iDecRandom = 1;

   m_dCWndSize = 16;
   m_dPktSndPeriod = 1;
   m_ExpectBW=m_MaxBW*0.1;
}

void CRUDPCC::onACK(int32_t ack)
{

	uint64_t currtime = CTimer::getTime();

	double minSP = 1000000.0 / (double(m_MaxBW) / m_iMSS);
		
	if((m_iRTT>m_iRTTRef*1.02) && m_iRTTRef>0)
	{
	
		if(!m_bCongestion)
		{
			m_bCongestion=true;
			m_lluBeginTime=currtime;

		std::streambuf* orig_buf=std::cout.rdbuf();
		std::ofstream file("output1.txt", std::ios::app);
		if(file.is_open())
		{
			std::cout.rdbuf(file.rdbuf());
			cout << m_Packets  << endl;
			std::cout.rdbuf(orig_buf);
		}
		file.close();

		}


                if(m_bBeginCongestionCtrl1 && !m_bBeginCongestionCtrl2)
		{
		
			m_SP+=m_step; //+abs(m_iRTT-m_iRTTRef)/m_iRTTRef
		}
	}

	if((m_iRTT<=m_iRTTRef*1.01) && m_iRTTRef>0)
	{
		if(m_bBeginCongestionCtrl1 && !m_bBeginCongestionCtrl2)
		{
			m_SP-=m_step;

		}
	}

	if(m_bCongestion)
	{

		if(currtime-m_lluBeginTime>0 && currtime-m_lluBeginTime<2000000)
		{
			m_step=5;
		}
		if(currtime-m_lluBeginTime>2000000 && currtime-m_lluBeginTime<20000000)
		{
			m_step=0.1;
		}
		if(currtime-m_lluBeginTime>20000000)
		{
			m_step=0.1;
		}
		
		if(m_bBeginCongestionCtrl1)
		{
		}
		else
		{
			m_bBeginCongestionCtrl1=true;
			m_SP=minSP*10;
		}
	}
	else
	{
		m_SP=minSP;
	}
 

		if(m_ExpectBW>m_MaxBW)
		m_ExpectBW=m_MaxBW;

   int64_t B = 0;
   double inc = 0;
 
   const double min_inc = 0.01;



   if (currtime - m_LastRCTime < (uint64_t)m_iRCInterval)
      return;

   m_LastRCTime = currtime;

   if (m_bSlowStart)
   {
    m_dCWndSize = m_dMaxCWndSize;
	m_bSlowStart = false;

	
      m_iLastAck = ack;
	
   }
   else   
   {
	   if(m_dCWndSize<m_iRcvRate / 1000000.0 * (m_iRTT + m_iRCInterval) + 16)
		m_dCWndSize = m_iRcvRate / 1000000.0 * (m_iRTT + m_iRCInterval) + 16;
	  m_dCWndSize = m_dMaxCWndSize;
   }
   m_dPktSndPeriod=m_SP;   
   if (m_bSlowStart)
      return;
   

   if (m_bLoss)
   {
      m_bLoss = false;
      return;
   }

   B = (int64_t)(m_iBandwidth - 1000000.0 / m_dPktSndPeriod);
   if ((m_dPktSndPeriod > m_dLastDecPeriod) && ((m_iBandwidth / 9) < B))
      B = m_iBandwidth / 9;
   if (B <= 0)
      inc = min_inc;
   else
   {
     
      inc = pow(10.0, ceil(log10(B * m_iMSS * 8.0))) * 0.0000015 / m_iMSS;

      if (inc < min_inc)
         inc = min_inc;
   }
   m_dPktSndPeriod=m_SP;
 
}

void CRUDPCC::onLoss(const int32_t* losslist, int)
{
	return;
   if (m_bSlowStart)
   {
      m_bSlowStart = false;
      if (m_iRcvRate > 0)
      {
         m_dPktSndPeriod = 1000000.0 / m_iRcvRate;
         return;
      }
   
      m_dPktSndPeriod = m_dCWndSize / (m_iRTT + m_iRCInterval);
   }

   m_bLoss = true;

   if (CSeqNo::seqcmp(losslist[0] & 0x7FFFFFFF, m_iLastDecSeq) > 0)
   {
      m_dLastDecPeriod = m_dPktSndPeriod;
      m_dPktSndPeriod = ceil(m_dPktSndPeriod * 1.125);

      m_iAvgNAKNum = (int)ceil(m_iAvgNAKNum * 0.875 + m_iNAKCount * 0.125);
      m_iNAKCount = 1;
      m_iDecCount = 1;

      m_iLastDecSeq = m_iSndCurrSeqNo;

      srand(m_iLastDecSeq);
      m_iDecRandom = (int)ceil(m_iAvgNAKNum * (double(rand()) / RAND_MAX));
      if (m_iDecRandom < 1)
         m_iDecRandom = 1;
   }
   else if ((m_iDecCount ++ < 5) && (0 == (++ m_iNAKCount % m_iDecRandom)))
   {
    
      m_dPktSndPeriod = ceil(m_dPktSndPeriod * 1.125);
      m_iLastDecSeq = m_iSndCurrSeqNo;
   }
}

void CRUDPCC::onTimeout()
{
	return;
   if (m_bSlowStart)
   {
      m_bSlowStart = false;
      if (m_iRcvRate > 0)
         m_dPktSndPeriod = 1000000.0 / m_iRcvRate;
      else
         m_dPktSndPeriod = m_dCWndSize / (m_iRTT + m_iRCInterval);
   }
   else
   {
    
   }
}

这段代码实现了网络传输简单的拥塞控制，在763Mbps，35ms延时网络中，当设定的传输速度为3Gbps时，第一次拥塞控制震荡较大，收敛时间比较长，最终传输速度只能到690-700Mbps，请详细分析该代码算法，提出优化解决的方案，在这段代码参数不变的条件下，重新用C++语言编写完整代码，并增加详细中文注释

				
			

			

				

					06-27
				

			

		

		

			
				
```cpp #include  #include   class MultiWindowCC { private:  // 基础参数（保持原始参数不变）  const uint32_t INIT_CWND = 2; // 初始拥塞窗口  const uint32_t INIT_SSTHRESH = 65535; // 初始慢启动阈值  ...

			
		

	





	

		

			

				
					
虚拟同步电机Simulink仿真与并电网模型仿真：参数设置完毕，可直接使用 - 电力电子

				
			

			

				

					08-09
				

			

		

		

			
				
如何利用Simulink对虚拟同步电机(Virtual Synchronous Generator,VSG)及其并电网模型进行仿真。首先概述了Simulink作为MATLAB的一部分，在电力电子仿真中的重要地位。接着阐述了虚拟同步电机的建模步骤，涵盖机械、电气和控制三个部分，并强调了参数设置对仿真精度的影响。然后讨论了并电网模型的构建方法，涉及电网结构、电压等级、线路阻抗等要素。随后讲解了参数设置的具体流程，包括电机初始状态、控制策略、并电网电压电流等。最后探讨了通过MATLAB编写控制策略和数据分析代码的方法，以及如何基于仿真结果评估电机性能和电网稳定性。
适合人群：从事电力电子领域研究的专业人士，尤其是那些对虚拟同步电机和并电网仿真感兴趣的工程师和技术人员。
使用场景及目标：适用于需要深入了解虚拟同步电机工作原理和并电网运行规律的研究项目。目标是在掌握Simulink仿真技巧的基础上，优化电机性能，提高电网稳定性。
阅读建议：由于涉及到大量的理论知识和技术细节，建议读者先熟悉Simulink的基本操作和相关电力电子基础知识，再逐步深入理解和实践文中提到的各种仿真技术和方法。

			
		

	





	

		

			

				
					
西门子Smart200 PLC控制V90伺服实现绝对定位与速度控制及PN通信调试

					
最新发布

				
			

			

				

					08-09
				

			

		

		

			
				
如何使用西门子Smart200 PLC控制两台V90伺服电机，实现绝对定位和速度控制的功能。文中涵盖了硬件组态、关键代码段、通信配置以及触摸屏设计要点，并提供了详细的调试说明和常见问题解决方案。主要内容包括：硬件连接方式、运动控制指令库的应用、IO映射配置、触摸屏界面设计、以及具体的调试步骤和注意事项。
适合人群：从事自动化控制系统设计与维护的技术人员，尤其是对西门子PLC和伺服系统有一定了解的工程师。
使用场景及目标：适用于工业自动化项目中需要精确控制伺服电机的位置和速度的情况。目标是帮助工程师快速掌握Smart200 PLC与V90伺服系统的集成方法，确保系统稳定可靠地运行。
其他说明：文中还提到了一些实用技巧，如坐标系转换设置、通信稳定性优化措施等，有助于提高项目的实施效率和成功率。

			
		

	





	

		

			

				
					
基于Maxwell方程的静电场电位分布研究及其工程应用 · Maxwell方程

				
			

			

				

					08-09
				

			

		

		

			
				
Maxwell方程在静电场电位分布研究中的应用。首先阐述了Maxwell方程组作为描述电磁场基本工具的重要性，接着具体分析了静电场中电场强度和电位分布的特点，特别是在不同电介质环境下的表现。文中还讨论了电位分布受地形、地貌、天气等因素的影响，并通过实际案例展示了静电场电位分布在电力传输等工程领域的应用。最后强调了准确描述静电场电位分布对于确保电力传输稳定性和安全性的重要意义。
适合人群：从事电气工程、物理学及相关领域的研究人员和工程师。
使用场景及目标：适用于需要理解和解决静电场电位分布相关问题的研究和工程项目，如电力传输系统的设计与优化。
其他说明：本文不仅提供了理论分析，还结合了实际案例，有助于读者更好地理解Maxwell方程在静电场电位分布中的应用。

			
		

	





	

		

			

				
					
elasticsearch-5.3.2.jar中文文档.zip

				
			

			

				

					08-09
				

			

		

		

			
				
1、压缩文件中包含：
中文文档、jar包下载地址、Maven依赖、Gradle依赖、源代码下载地址。
2、使用方法：
解压最外层zip，再解压其中的zip包，双击 【index.html】 文件，即可用浏览器打开、进行查看。
3、特殊说明：
（1）本文档为人性化翻译，精心制作，请放心使用；
（2）只翻译了该翻译的内容，如：注释、说明、描述、用法讲解 等；
（3）不该翻译的内容保持原样，如：类名、方法名、包名、类型、关键字、代码 等。
4、温馨提示：
（1）为了防止解压后路径太长导致浏览器无法打开，推荐在解压时选择“解压到当前文件夹”（放心，自带文件夹，文件不会散落一地）；
（2）有时，一套Java组件会有多个jar，所以在下载前，请仔细阅读本篇描述，以确保这就是你需要的文件。
5、本文件关键字：
jar中文文档.zip,java,jar包,Maven,第三方jar包,组件,开源组件,第三方组件,Gradle,中文API文档,手册,开发手册,使用手册,参考手册。

			
		

	





	

		

			

				
					
word文档编辑器软件打包保存程序代码QZQ-2025-8-9.txt

				
			

			

				

					08-09
				

			

		

		

			
				
word文档编辑器软件打包保存程序代码QZQ-2025-8-9.txt

			
		

	





	

		

			

				
					
酷派F608刷机新系统发布：版本1.02.042.100618

				
			

			

				

					
				

			

		

		

			
				
在压缩包子文件的文件名称列表中，“1.02.042.100618.F608(不擦校准参数).binx”指出了固件文件的具体名称和类型。“binx”文件后缀表示该文件是一个二进制文件，通常用于固件更新。文件名中的“不擦校准参数”意味...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值