theory

It seems to me that a lot of my debugging time is spent chasing down null-reference exceptions in complex statements. For instance: For Each game As IHomeGame in _GamesToOpen.GetIterator() Why, when I get a NullReferenceException, can I get the line number in the stack trace, but not the name of the object that equals null. In other words, why: Object reference not set to an instance of an object. instead of _GamesToOpen is not set to an instance of an object. or Anonymous object returned by _GamesToOpen.GetIterator() is null. or game was set to null. Is this strictly a design choice, meant to

Of course this is an impossible statement in java (to-date), however ideally I would like to implement it as it is at the heart of many iterations. For example the first multiple times it is called I'm doing it 650,000+ times when it is creating the ArrayList . Unfortunately the reality is that my actual code does not have the set inside the else loop; thus it will pass over both the add and then the set commands and wasting time. After that I have it also in another loop where it is only performing the set as the data is already created and this is multi-nested with in many others so it is a

Out of curiosity, I was wondering what were some "theoretical" results about parsing C++. Let n be the size of my project (in LOC, for example, but since we'll deal with big-O it's not very important) Is C++ parsed in O(n) ? If not, what's the complexity? Is C (or Java or any simpler language in the sense of its grammar) parsed in O(n)? Will C++1x introduce new features that will be even harder to parse? References would be greatly appreciated! I think the term "parsing" is being interpreted by different people in different ways for the purposes of the question. In a narrow technical sense,

I have been working on latent semantic analysis lately. I have implemented it in java by making use of the Jama package. Here is the code: Matrix vtranspose ; a = new Matrix(termdoc); termdoc = a.getArray(); a = a.transpose() ; SingularValueDecomposition sv =new SingularValueDecomposition(a) ; u = sv.getU(); v = sv.getV(); s = sv.getS(); vtranspose = v.transpose() ; // we obtain this as a result of svd uarray = u.getArray(); sarray = s.getArray(); varray = vtranspose.getArray(); if(semantics.maketerms.nodoc>50) { sarray_mod = new double[50][50]; uarray_mod = new double[uarray.length][50];

I'm hearing more and more about domain specific languages being thrown about and how they change the way you treat business logic, and I've seen Ayende's blog posts and things, but I've never really gotten exactly why I would take my business logic away from the methods and situations I'm using in my provider. If you've got some background using these things, any chance you could put it in real laymans terms: What exactly building DSLs means? What languages are you using? Where using a DSL makes sense? What is the benefit of using DSLs? DSL's are good in situations where you need to give some

gan部分的理论，最开始的版本。这里面其实有一些问题 我们想要找到一个高维空间中的分布 P_data(x)，在目标类别的区域，probability是高的，在那个区域之外，probability是低的。但这个P_data(x)分布的具体形式是不知道的 没有gan怎么做生成？ maximum likelihood estimation！ 1.从P_data(x)中sample一些数据作为训练数据 2.我们有一个含有未知参数theta的分布P_G(x; theta)，想做的事情就是找出能够让P_G和P_data最接近的参数theta。比如我们有一个混合高斯分布GMM作为P_G(x; theta)，theta就是Gaussians的means和variances 3.由训练数据{x1, x2, ..., xm}计算P_G(xi; theta) 4.likelihood就定义为所有可能的i，P_G(xi; theta)的连乘 5.就用gradient ascent 让这个likelihood最大 maximum likelihood estimation 等价于 minimize KL Divergence 原因在于，可以对概率取对数 然后可以把连乘号拿出来，变成求和： 这个式子就是对期望的估计 然后计算这个期望，就是对x求积分 然后加一个和P_G完全无关的项，也就是不含theta的项