精华内容
下载资源
问答
  • OPEN哈希表实现单词本

    2017-12-10 14:21:57
    一、算法思想 哈希表是根据关键码值而直接进行访问的数据结构,也就是说它可以通过对关键字进行某种函数映射直接找到其对应的表中的位置,这个映射函数叫做哈希函数。 由于哈希表中不需要比较即可找到所需元素,...

    一、算法思想

    哈希表是根据关键码值而直接进行访问的数据结构,也就是说它可以通过对关键字进行某种函数映射直接找到其对应的表中的位置,这个映射函数叫做哈希函数。

    由于哈希表中不需要比较即可找到所需元素,能够极大节省查找所需时间,但哈希表中在存储的时候可能会出现不同关键字通过函数映射却对应哈希表中同一位置的情况,这种情况我们称之为冲突。人们对此提出了两种解决方法,开放定址法(OpenAddressHash)和封闭定址法(CloseAddressHash),此次作业主要应用开放定址法来解决冲突。

    开放定址法即如果一个元素的Hash地址对应的Hash单元已被另一个元素占有(冲突),我们需定义一个候选地址序列,每当发生冲突时,就选择下一个地址去试探,循环重复此过程。

     

    二、设计思路

    由于在题目中已经给出要存储的数据大小和类型,因此首先最重要的应该是确定合适的哈希表容量。效率较高的哈希表数据容量一般为待存数据量的2倍,且为素数。因为本作业要求存储1000个单词,所以选择哈希表容量大小为2729 其次要确定合适的哈希函数,根据题目确定了关键字为单词的前三个字母,此函数同时要较好地适应哈希表大小,因此最终决定采用编码方式,即先计算首字母的ASCI码值*26*26、次字母的ASCI码值*26、再次字母的ASCI码值的总和,再用此总和对哈希表大小(即2729)取模。最终能够达到较好的存取效率。

     

    三、程序代码




    四、测试例

    手工输入了21个单词作为测试,结果中将输出单词和该单词在哈希表中的位置。


    五、运行结果

    结果中显示出单词以及该单词在哈希表中所在位置。


    六、分析

    本作业中对于哈希函数的设计主要受到了二进制编码方式的启发,对于关键字,即单词中三个字母的选择是有关于哈希表大小的考虑,如果关键字定义为两个字母,按编码方式所需要的最大的地址空间为26*26+26=702,小于哈希表的数据容量大小。而选择三个字母时,按该编码方式所需要的最大的地址空间为26*26*26+26*26+26=18278,大于哈希表的数据容量大小,最终只需要再将其取模变成适合哈希表大小即可。

    本作业中最大的问题在于单词输入时需要手工输入,费时费力,如果能够改写为从文本中读取,将节省很多人工输入单词的时间。


    展开全文
  • 如果使用嵌套组件化思想,此父子组件相互传参就比较简单,没有技术难度,实现起来也比较简单。使用window.open()弹出新页面,难度在于父子间的通信,研究了很久,子组件使用h5中的postMessage方法,通过父组件监听方...

    直接上效果:

    在这里插入图片描述

    情景描述: (vue+element-ui)
    在这里插入图片描述
    前面显示,显示数据来源来之后面按钮,点击按钮弹出一个新的页面,弹出新的弹框使用的是window.open();如果使用嵌套组件化思想,此父子组件相互传参就比较简单,没有技术难度,实现起来也比较简单。使用window.open()弹出新页面,难度在于父子间的通信,研究了很久,子组件使用h5中的postMessage方法,通过父组件监听方法,实现通信,在用父组件向子组件通信时使用同样的方法时,遇到了问题,暂时没有解决,用了一个简单的方法获取父组件的值。
    原始的用意想在父子组件通过固定的方法获取父组件传递的数据和子组件触发固定方法,能把值传给父组件。

    子组件向父组件通信:

    confirm:function()
        {
            debugger;
        
            // type 用来
            var json = {type:'echoInfo',data:[]};
            json.data = this.selected ;
            // var jsonStr = JSON.stringify(json);
            // 使用 h5中的postMessage 能解决页面跨域问题 第一个参数表示 需要回传的数据,第二个参数时url * 表示不限制
            window.opener.postMessage(json,'*');
            window.close();
        },
    

    父组件监听:

    //生命周期 - 挂载完成(可以访问DOM元素)
    mounted() {
        var that = this ;
         window.addEventListener('message', function(e){
    
            if(e.data !=undefined && e.data !='' ){
              debugger
              if(e.data ==undefined || e.data ==''){
                    return ;
                } 
                // var json = JSON.parse(e.data);e.data;
                var json = e.data;
                if(json.type =="echoInfo")
                {
                    that.echoData = json.data ;// 传递过来的值
                    that.receiveMessage(json.data);
                }
            }
    
        });
    },
    

    父组件—>子组件的通信 (以下方案 不具有通用性,不建议使用,只是提供一种思路

      <el-input id="parentValue" v-model="echo" placeholder="能确定回显内容的唯一值,如id" disabled ></el-input>
    
     window.open(BaseUrl+"/#/elementTable", 'newwindow', 'height=800, width=1200, top=0, left=0, toolbar=no, menubar=no, scrollbars=no, resizable=no, location=no, status=no');
    

    子组件获取父组件的值

      var echoInfo =  window.opener.document.getElementById("parentValue").value;
    

    el-table表格回显的key point code:

    if (this.selected !=undefined && this.selected !='') {
        for(var i=0;i<this.pagination.resultList.length;i++){
           for(var j=0;j<this.selected.length;j++){
             if(this.pagination.resultList[i].name===this.selected[j].name){
                   this.$refs.multipleTable.toggleRowSelection(this.pagination.resultList[i]);// 回显选中默认数据的关键点
                }
              }  
            }
           
        } else 
        {
              this.$refs.multipleTable.clearSelection();
        }
    
    <el-table
                    ref="multipleTable"
                    :data="pagination.resultList"
                    @select="onSelect"
                    @select-all="onSelectALL"
                    style="width: 100%">            <!--  :selectable="selectable" -->
                    <el-table-column type="selection"  :reserve-selection="true"></el-table-column>
                    <el-table-column label="日期" width="180">
                        <template slot-scope="scope">
                            <i class="el-icon-time"></i>
                            <span style="margin-left: 10px">{{ scope.row.date }}</span>
                        </template>
                    </el-table-column>
                    <el-table-column label="姓名" width="180">
                        <template slot-scope="scope">
                            <el-popover trigger="hover" placement="top">
                            <p>姓名: {{ scope.row.name }}</p>
                            <p>住址: {{ scope.row.address }}</p>
                            <div slot="reference" class="name-wrapper">
                                <el-tag size="medium">{{ scope.row.name }}</el-tag>
                            </div>
                            </el-popover>
                        </template>
                    </el-table-column>
                    <el-table-column
                        prop="address"
                        label="地址"
                        :formatter="formatter">
                    </el-table-column>
                    <el-table-column
                        prop="tag"
                        label="标签"
                        width="100"
                        :filters="[{ text: '同学', value: '同学' }, { text: '老师', value: '老师' }]"
                        :filter-method="filterTag"
                        filter-placement="bottom-end">
                        <template slot-scope="scope">
                            <el-tag
                            :type="scope.row.tag === '家' ? 'primary' : 'success'"
                            disable-transitions>{{scope.row.tag}}</el-tag>
                        </template>
                        </el-table-column>
                    <el-table-column label="操作">
                        <template slot-scope="scope">
                            <el-button
                            size="mini"
                            @click="handleEdit(scope.$index, scope.row)">编辑</el-button>
                            <el-button
                            size="mini"
                            type="danger"
                            @click="handleDelete(scope.$index, scope.row)">删除</el-button>
                        </template>
                    </el-table-column>
                </el-table>
    

    涉及跨页回显时的处理,监听表格数据的变化

     selected:[],// 实时选中数据,用于回显 记录需要回显的数据 实时更新
     falseList:[],// 记录取消的数据
     trueList:[],// 记录选中的数据
    
    

    监听数据的变化: selectedd的数据就是需要默认选中的数据,此字段是实时更新的。

     watch:{
          pagination:function(op)
          {
              debugger;
              this.resultList = op.resultList ;
          },
          falseList:function(value)
          {
              
              if(this.trueList.length == 0)
              {
                  var totalArray = this.mergeArrayRelaseSame(this.selected,this.trueList);
                  if(this.falseList !='' && this.falseList.length !=0)
                  {
                      // 总数据中删除 取消的数据
                      
                      var len = this.falseList.length ;
                      for(var i=0;i<len;i++)
                      {
                          var totalLen = totalArray.length ;
                          for(var j=totalLen -1 ;j>=0;j--)
                          {
                            
                            if(totalArray[j].id == this.falseList[i].id){
                                totalArray.splice(j,1);
                                break
                            }
                          }
                      }
                  }
                  this.selected = totalArray ;
                  console.log(this.selected);
              }
               
          },
          trueList:function(value)
          {
              // 开始回显的数据+进入页面选中的数据-清除选中的数据
              // selected+trueList-falseList
              var totalArray = this.mergeArrayRelaseSame(this.selected,this.trueList);
              if(this.falseList !='' && this.falseList.length !=0)
              {
                 // 总数据中删除 取消的数据
                var totalLen = totalArray.length ;
                var len = this.falseList.length ;
                for(var i=0;i<len;i++)
                {
                    for(var j=totalLen -1 ;j>=0;j--)
                    {
                   
                    if(totalArray[j].id == this.falseList[i].id) // 判断数据是否需要删除的依据
                    { 
                        totalArray.splice(j,1);
                        break
                    }
                    }
                }
              }
              this.selected = totalArray ;
              console.log(this.selected);
               
          },
      },
    

    关键处理代码:

    思路:实时监听选中和取消的数据,并实时计算需要回显的数据并实时更新selected,保证准确性。完全具备通用性。

    此处参考文档地址:https://juejin.im/post/5d0091236fb9a07eec59c265

    **项目中需要需要实时更新回显,跨页回显,此博文给我本人很好的解决思路,完美的解决了当时遇到的问题,本人结合原作者文章给予的思路和参考处理方案,部分引用原作者代码。完美解决问题,在此。对作者表示感谢。
    **

    //表格当前页全选出发函数
        onSelectALL:function(rows)
        {
            this.indeterminate = true ;
            var lenNow = this.resultList.length;
            // 判断勾选全选本页是选中 还是取消
            if(rows.indexOf(this.resultList[0]) !== -1)
            {
                debugger
                //选中
                for(var i=0; i<lenNow ;i++)
                {
                    // 记录撤销数组 选中后删除数据操作
                    for(var n = 0;n<this.falseList.length;n++)
                    {
                        if(this.falseList[n].id== this.resultList[i].id)
                        {
                            this.falseList.splice(n,1)
                        }
                    }
                    // 记录选中数据数据 选中部分操作
                    if(this.trueList.length !== 0)
                    {
                        if(this.trueList.indexOf(this.resultList[i]) === -1)
                        {
                            this.trueList.push(this.resultList[i]);
                        }
                    }
                    else
                    {
                        if(this.trueList.indexOf(this.resultList[i])=== -1)
                        {
                           this.trueList.push(this.resultList[i]);
                        }
                    }
                }
            }
            else
            {
                debugger
                // 取消操作
                for(var j=0;j<lenNow;j++)
                {
                    // 记录撤销的操作 往记录撤销数组中添加数据
                    if(this.falseList.length !== 0)
                    {
                        if(this.falseList.indexOf(this.resultList[i])=== -1)
                        {
                            this.falseList.push(this.resultList[j]);
                        }
                    }
                    if(this.falseList.length === 0)
                    {
                        this.falseList.push(this.resultList[j]);
                    }
                    // 记录选中的相关操作 撤销时,删除已选中的数组中的取消的数据的删除
                    if(this.trueList.length !==0)
                    {
                        for(var n = 0; n<this.trueList.length;n++)
                        {
                            if(this.trueList[n].id === this.resultList[j].id)
                            {
                                this.trueList.splice(n,1);
                            }
                        }
                    }
                }
            }
            
        },
        // 选中数据操作
        onSelect:function(rows,row)
        {
            this.indeterminate = true ;
            var selected = rows.length && rows.indexOf(row) !== -1
            var lenFalse = this.falseList.length
            var lenTrue = this.trueList.length
            if(selected)
            {
                // 选中
                // 对记录撤销选中的计算 falseList
                if(lenFalse !== 0)
                {
                    for(var i=0;i<lenFalse;i++)
                    {
                        if(this.falseList[i].id === row.id)
                        {
                            this.falseList.splice(i,1);
                            break
                        }
                    }
                }
                // 对记录选中的数据的计算 trueList
                if( lenTrue !=0)
                {
                    if(this.trueList.indexOf(row.id) === -1)
                    {
                        this.trueList.push(row);
                    }
                }
                if(lenTrue ==0)
                {
                    this.trueList.push(row);
                }
    
            }
            else
            {
                // 取消 falseList
                this.falseList.push(row);
                // trueList 操作
                for(var i=0;i<lenTrue;i++)
                {
                    if(this.trueList[i].id===row.id)
                    {
                        this.trueList.splice(i,1);
                        break
                    }
                }
    
            }
        },
        // 数据合并并去重  arr [{id:'',value:''},...]
        mergeArrayRelaseSame: function(arr1,arr2)
        {
            var mergeArray = arr1.concat(arr2);
            var newArray = [] ; //存放去重后的数据的新数组
            for(var i=0;i<mergeArray.length;i++)
            {
                var item1 = mergeArray[i];
                var flag = true ;
                for(var j=0;j<newArray.length;j++)
                {
                    var item2 = newArray[j];
                    if(item1.id == item2.id)
                    {
                       flag = false ;
                    }
                }
                if(flag)
                {
                    newArray.push(item1);
                }
            }
            return newArray ;
    
        },
    

    以上仅仅为关键点的代码。源码代码路径为:

    https://github.com/zhao0215/echotable

    ps:欢迎转载,转载请标明本文章原文地址。

    展开全文
  • OpenAI Gym 关于CartPole的模拟退火解法

    千次阅读 2016-05-03 21:38:01
    关于模拟退火法一种最优控制算法,基本思想就是每次找一个邻近的点(解法),如果邻近的点比较优,就接受这个点,但是下一次使用随机有一定概率继续选择新的邻近的点,从而避免局部最优,从而通过多次

    前言

    今天测试OpenAI Gym,然后发现CartPole的最快实现快到离谱,使用Simulated Annealing,也就是SA模拟退火法。效果如下图:
    这里写图片描述

    代码地址:模拟退火解CartPole

    于是好好研究了一下。

    关于模拟退火法

    一种最优控制算法,基本思想就是每次找一个邻近的点(解法),如果邻近的点比较优,就接受这个点,但是下一次使用随机有一定概率继续选择新的邻近的点,从而避免局部最优,从而通过多次测试达到全局最优。

    比较清楚的介绍详见:大白话解析模拟退火算法

    如何将模拟退火法SA应用到CartPole中?

    对于CartPole倒立摆,其控制输出A很简单,就是向左或者向右。输入O就是车的位置,速度,杆的角度,角速度。

    为了应用SA,首先需要构造一个从输入到输出的映射:

    A=f(O)

    那么这里显然我们可以使用最简单的映射,就是线性映射:

    A=wO

    w 即为参数向量。模拟退火就来改这些参数,从而得到一个新的“点”。

    再下来的问题就是如何判断w好坏了,想法也很简单,每次运行一次episode即一次实验,累加计算得到的reward值,用Score得分表示,代表这个参数效果更好。

    所以接下来是思路就简单了:

    初始化w
    初始化最优w
    初始化动作选择w
    
    每次给动作选择w增加一点随机性,(随机性不断减少),计算得到的回报Score
    如果Score 最大,就将当前的w赋给最优w,并将最优w赋给动作选择w
    如果Score 小,那么可以增大随机性。
    
    反复运算,值得一定时间w不再波动(即不再退火)

    更具体的大家可以参考代码。这里只分析一下思路。

    思考

    模拟退火法是一种类贪婪算法,通过纯随机的方式来寻找更优的结果。对于低维空间可以,但对于高维控制,这种方向性不强的做法(比起随机梯度下降恐怕就不好了)

    展开全文
  • fairyui,opensource源代码

    2010-07-13 09:00:14
    由于工作比较繁重,不回答如何配置环境、如何编译运行等一些比较初级的问题,也不就代码中的结构和注释问题进行回答(注释也算是比较多了吧),仅仅只讨论提高效率的问题。 另外,此代码不可用于商业用途,个人作品如...
  • OpenAI Baselines是强化学习算法的一组高质量实现。 这些算法将使研究团体更容易复制,完善和识别新思想,并创建良好的基线以在其上进行研究。 我们的DQN实施及其变体与已发表论文的得分大致相当。 我们希望它们将...
  • open64--编译过程 compile process

    千次阅读 2010-01-01 09:41:00
    一、优化控制的思想1、低层的优化编译时间短; 优化不容易出错; 计算的精确性比较高; 生成代码执行比较慢(?)。2、高层的优化编译时间长; 优化比较激进; 通过牺牲计算的精确性,来保证高的性能; 生成的代码...

    一、优化控制的思想

    1、低层的优化

    编译时间短; 优化不容易出错; 计算的精确性比较高; 生成代码执行比较慢(?)。

    2、高层的优化

    编译时间长; 优化比较激进; 通过牺牲计算的精确性,来保证高的性能; 生成的代码执行比较快(?)。

    3、好的优化会通过多个选项来控制

    4、优化选项和对应的阶段

    -O0: -g时的默认选项,只走FECG,所有优化都关闭;

    -O1: 只走FECG,打开局部优化;

    -O2: 默认选项,打开WOPT和剩余CG的优化;

    -O3: 打开LNO

    -IPA: 打开IPA

    5、群组选项

    选项通过编译阶段或者所做优化的特性来分成不同的组,一般语法如下:

    -GROUPNAME:opt[=val]{:opt=[val]}

    一些类似于GNU选项的flag

    -march -ffast-math -ffloat-store -fno-inline

    其他一些组选项:

    -LIST: 用户列表? User listing

    -OPT: 优化

    -TARG: 目标机器

    -TENV: 目标环境

    -INLINE: 后端inline

    -IPA: 过程间分析

    -LANG: 语言特点

    -CG: 代码生成

    -WOPT: 全局标量优化

    -LNO: 嵌套循环优化

    6driver在编译器中的作用

    相关的文件在 open64/driver 文件夹下;

    作用是处理所有的命令行选项;

    调用所有编译的阶段:preprocessor(处理器之前?)、前端、内联、后端(be, lno, wopt, cg)、汇编、链接;

    维护与GNU选项的一致性;

    1、编译器驱动器

    1 open64/driver/OPTIONS文件

    记录了选项的详细说明;

    可以将一个选项对应到另一个不同的选项上去??

    2 单个可执行的,多个软连接??( single executable, multiple soft links)

    3 arg[0]字符串用来辨别编程语言

    4 查询与编译器相关的环境变量

    5 在缺省选项 –march=auto 时,查询主机处理器的信息

    6 为系统特定的选项查询编译器的缺省选项文件

    二、CC++的前端

    1C/C++前端的历史

    12000年开放源码时,使用的是GNU2.95的前端

    采用的是将GNU的中间树直接翻译成whirl形式;

    CC++使用独立的前端嵌入到open64里;

    22004年更新到GNU3.3.1的前端

    32006年为虚拟的目标机定义了.spin文件格式

    Open64不再将GNU编译器当做自己的一部分进行维护;

    将更新到每个GNU版本的工作进行了简化;

    CC++消失之间复制代码??(duplicate code between C and C++ eliminated

    420073月移植GNU4.0.2的前端

    5200710月移植GNU4.2.0的前端

    6)为将来其他GNU语言留有扩展

    2、使用GNU编译器做前端

    1 最开始使用X86-64上的GNU编译器

    A老方法是:

    Copen64/kgccfe前端;

    C++open64/kg++fe的前端;

    GNU代码中嵌入生成whirl的调用;

    C++要求运行整个的编译过程去汇编生成完整的转换后的数据;

    使用CC++中的多个源码树;

    B新方法是:

    gspin树节点作为模拟GNU树的元素,在libspin库中实现此功能,同时可以打印到.spin文件中;

    gcc编译过程中添加识别点来拦截GNU

    gcc/tree.c中,用GNU树生成gspin树节点;

    Open64/wgengspin树节点(.spin文件)翻译成whirl节点(.B文件),wgen的操作模式在kgccfe/kg++fe之后被模拟??( wgen’s mode of operation modeleted after kgccfe/kg++fe)

    2 Gspin树节点

    GNU树中的信息完整的转到.spin文件中;

    8字节的gspin节点作为原子建立块;在libspin/gspin-tree.h中定义gspin nodes gspin nodes代表GNU树节点中的一个域的信息;连续的几个gspin nodes代表一个GNU树节点;表示图在libspin/gspin-tel.h中定义;

    Libspin负责管理已经分配的gspin节点

    Gspin nodesI/O通过mmap()处理

    DumpASCII码,为避免无限递归,每个节点只dump一次

    Gspin nodes的一个例子(如下图):

    三、Fortran前端

    1、历史

    Fortran前端源于cray fotran compiler

    现在fotran前端包括:cray fortran 前端 生成whirl的适配器。

    多个运行时的库文件:libF77, libI77, libU77, libfi, libf, libu. 其中,libfortan.so包含了前面所有的库文件。

    修正了很多的bug,并且在pathscale上进行了增强。

    2Fortran前端的实现

    Fortran90的前端分三个子阶段:

    1 词法分析和语法分析阶段 Lexer(src_input.c, lex.c) and Parser(p_*.c)

    程序被表示为树的形式;

    在一堆表格中(sytb.*),树节点是入口:

    Scp-tbl 表示作用域;

    SH-tbl表示语句头;

    global_name_tbl, name_tbl表示Fortran标示符;

    AT_tbl表示变量和过程的属性节点;

    CN_Tbl表示常量的值;

    IR_Tbl表示操作符节点;

    IL_Tbl表示列表链接节点;

    还有很多表示数组界限,文件名的表格。

    2)语义阶段(s_*.c

    主要处理不能在语法阶段即时转换的操作。

    3)生成whirl的阶段

    函数cvrt_to_pdg()和函数send*() (在icvrt.c文件中)转换树和符号表为所需要的形式;然后调用crayf90/sgi下的程序生成whirl

     

    调试所需:

    build时加入-D_DEBUG

    运行mfef95时,加入:-uall (打印所有表格处理)-uir2(打印用的最多的表格);

    mfef95debug时,可以调用fe90/debug.c下的程序。

    四、Goto转换

    1、将用goto语句所写的循环转换为高层循环的形式,从而为LNO提供良好支持。

    2goto转换的理论基于Ana ErosaLaurie Hendren的一篇论文。

    3、在LNO之前会调用一次goto转换(be/com/opt_goto.cxx文件中)

    4GNU4.2的前端不再生成高层循环的结构。

    5、为了方便VH whirl的使用,在后端的开始部分,添加了新阶段(在be/be/goto_conv.cxx文件中)

    五、VH whirl 优化

    Lowerhigh whirl时做一些优化

    1、第一部分处理常见的语言结构(be/vho/vho_lower.cxx

        其中的优化包括:

            位域的优化;

            short-circuit boolean expressions:就是尽快判断出布尔表达式的值;

            switch语句的优化;

            简单的if语句的转换;

            将小的结构体的复制lower成对各个对立域的赋值;

            将一些代码序列转化为intrinsics

            还有其他一些基于类型的优化:max, min

    2、第二部分,将fotran90的结构生成高效的代码(be/vho/f90_lower.cxx

        数组部分的操作扩展为循环;

        为了保留语义上并行的部分,引入数组临时变量,例如:

    六、Lowering

    VHO之后的所有lowering都是通过调用wn_lower()函数实现的(be/com/wn_lower.cxx);参数LOWER_ACTIONS的每一位都控制了一种类型的lowringlowring会递归的遍历这棵树,并且在其中对节点应用相关的lowring    Mostly simple tree transformation???

    七、whirl的简化器(whirl simplifier

    它的作用是将whirl树简化为另一种更加有效地形式。

    它在common/com/wn_simp_code.h中实现。当调用WOPT时,树节点类型被转为wn或者coderep;同时前端会将常数表达式转为常量。

    在生成whirl树时会自动调用whirl简化器,因为它是代价最小的优化方式,所以在任何一次转换发生时,都应该调用一下whirl简化器。

    八、链接转换

    实现:common/com/x8664/targ_sim.cxx

    控制:在lower时调用;处理如何将不同类型的参数进行传递;处理如何返回不同类型的函数返回值。

    Fake parameters for return structs introduced by lowerer??

    九、数据层 data layout

     

    1

    作用:解决程序中变量的存储分配问题(变量在编排之前都是离散不连续的)。

    出现的优化机会有:对齐;引用的局部性。

    策略:延迟优化直到可以看见分配某些相对位置的收益。

     

    2mechanism

    设计的一个方向是使它能在优化和编译阶段连续的使用。

    发生阶段:IPAcommon块分裂和padding

                   LNO,强制对齐

    等级的数据层表示:对每个符号,使用ST_baseST_ofst表示位置。ST_base可能会晚些展开。

     

    3、堆栈的数据层

    实现:be/com/data_layout.cxx

    主要处理:形参、Fixed temporaries for Fortran alternate entry parameters??、实参、其他一些局部变量(用户或者编译时生成的)。

    几种堆栈类型:small(只使用$sp),  large(使用$fp $sp)dynamic(使用$fp $sp

    在代码生成的最后,堆栈也确定了,st_base被按照$sp or $fp设置

     

    展开全文
  • 转自基金会网站:http://osgeo.org/news/index.html其中的报道都是比较有深度的,值得一看。2.4日的会议已经开了,9月份在瑞士还有一次会议。刚刚在MapServer的邮件...国外很多Bloger和3S相关的网站都在报道Open S...
  • 一篇比较新的文章,看简介就吸引了我:其中提到的核心思想与唐师兄说的非常相似。描述method的关键词也如此。题目倒是非常怪异,可能是为了吸引眼球吧。思想主要是目标检测中classification和regression的解耦。 ...
  • 故单单是这块的软件做得比较少,估计工作上只能做些网络这块的辅助应用而已; 这样子,可能会对objective-c熟悉,fundation框架熟悉,对UIKIt,Cocoa Touch API 、(Quartz 2D,Open GLES 、OpenAL)等SDK不熟悉的...
  • 通过机器学习对CDC的健康数据和OpenStreetMap的POI数据进行分析,以找到健康社区的设计标准。 主要思想是获取不同类别的POI数据的数量,并将它们与CDC的运行状况评估数据进行空间合并。 该项目的第一步是功能选择...
  • 几种常见的开源协议比较

    千次阅读 2015-08-01 17:11:16
    根据Open Source Initiative的统计现在开源的协议已经有几十种了(我数了下有70个生气 http://www.opensource.org/licenses/alphabetical),他们都是基于开源思想而订立的,要全部熟悉没那个精力也没有那个必要,...
  • 目前开放源代码的加密库中,openssl和cryptlib都是比较流行的,本文将根据自己的一点理解对这两个库作一些比较,希望能对大家有用。这两个库的构造思想和目的都不太一样. Openssl主要是针对SSL/TLS协议的实现,SSL的...
  • 从目前的两种技术发展来看,两种方法都是webservice( RPC ) 的实现,调用一个接口,...所以,SOAP肯定会有相应的软件组件来构建、验证监测webservice,而REST的实现就五花八门了,其实现在很多大公司的OPEN API ,很...
  • 最近几天集中看了Alisoft的Open API原理,及Google API (包括相关的Gadget API),尝试讨论Open API背后的各异的思想。 在讨论各自API的设计思想前,先简介两种API的作用:Alisoft和Google的应用当然
  • 我假定你有一些HTML(或者HTML编辑器)的基本知识和一些编程思想。 1.简介 PHP是能让你生成动态网页的工具之一。PHP网页文件被当作一般HTML网页文件来处理并且在编辑时你可以用编辑HTML的常规方法编写PHP。 PHP...
  • 11.1 错误处理

    2021-03-10 14:24:06
    Go语言主要的设计准则是:简洁、明白,简洁是指语法和C类似,相当的简单,明白是指任何语句都是很明显的,不含有任何隐含的东西,在错误处理方案的设计中也贯彻了这一思想。我们知道在C语言里面是通过返回-1或者NULL...
  • Dijkstra算法(迪杰斯特拉算法)是比较常用的最短路径算法,可以算是贪心思想的实现。贪心思想是在对问题求解时,总是做出在当前看来是最好的选择。 Dijkstra算法核心就是求出局部最优解。下面用open,close表描述...
  • Open Closed Principle “开”指的是允许一个类甚至往大了说允许一个系统随时可以对自己的功能进行扩展。 “闭”指的是不允许在扩展和修改功能的时候触及到已经写好的底层代码(比如父类)。 举一个比较浅显的
  • 开-闭原则(目标、总的指导思想Open ClosedPrinciple “开”指的是允许一个类甚至往大了说允许一个系统随时可以对自己的功能进行扩展。 “闭”指的是不允许在扩展和修改功能的时候触及到已经写好的底层代码...
  • 九宫格 数字移动 ~

    2008-11-25 11:26:04
    也就是Open表中的第一个结点,取出之后进行比较是否为目标结点,是则找到,没有则扩展(在这个程序中,扩展就是将空格进行上,左, 下,右移动),扩展之后的结点放入Open表中,然后将已经进行扩展的结点放入Close表...
  • Python的with内部原理解析

    千次阅读 2016-08-22 11:40:14
    with open('test.txt') as f: print f.read()短短的几行代码既能够实现对文件的读取,但是我们怎样创建一个自己的额class并支持with关键字呢? Python对with的处理还很聪明。基本思想是with所求值的对象必须有一个_...
  • 开-闭原则(目标、总的指导思想Open Closed Principle “开”指的是允许一个类甚至往大了说允许一个系统随时可以对自己的功能进行扩展。 “闭”指的是不允许在扩展和修改功能的时候触及到已经写好的底层...
  • 题目: PullNet: Open Domain Question Answering with Iterative Retrieval on Knowledge Bases and Text 来源: EMNLP 2019 ...作者: Lijuce ...目前比较好的思想是早期融合(early fusion)和后期融合(late
  • 代码实现的比较糙,但是基本原理一看就明白。 一、主要核心思想: 1)创建pty终端,即open("/dev/ptmx", O_RDWR | O_NOCTTY),关于pty的介绍网上有很多,这里简单说明一下pty类似我们管道,但是pty是全双工的。pty...
  • 本博客中中文分词索引页

    千次阅读 2010-11-05 17:45:00
    中文分词系统理论:搜索引擎技术揭密:中文分词技术 这篇文章概念讲得比较清晰搜索引擎之中文分词(Chinese Word Segmentation)简介中文自动分词 ——摘自《搜索引擎 ——原理技术与系统》 摘自一本书,算法思想讲...
  • AekdyCoin出过的ACM题

    千次阅读 2013-08-09 17:16:06
    以下转载AekdyCoin的Blog,可以用来学习出题者思想。 1. Mod Tree (HDU 1st “Old-Vegetable-Birds Cup” Programming Open Contest ) 本人出的第一个题目,考察的是扩展Baby-step Giant-step,...
  • A Star算法

    2016-04-01 11:59:09
    A Star算法是一智能找最短路径算法(下面简称A算法), 与 Dijkstra算法相比,A算法访问的节点比较少,因此可以缩短搜索时间。他的算法思想是:这里有公式f 最终路径长度f = 起点到该点的已知长度h + 该点到终点的估计...

空空如也

空空如也

1 2 3 4 5 6
收藏数 116
精华内容 46
关键字:

思想比较open