I don't know of a study on the question you're asking, but I do have some information to add—and possibly a better way to approach the X in your XY problem.
First, let's look at your example:
in Chinese: 6 sinograms
中囯大, 日本小 can encode the same information as 22 latin letters in English
China is big, Japan is small
The number of sinograms in an average literate Chinese native is somewhere in the ballpark of 8000, while English only has 26 letters (plus a few symbols, in both cases, but let's ignore symbols and spaces, as you already have). This means that, in information theoretic terms, each sinogram represents about 13.0 bits, each letter about 4.7. So we're really talking about 78 bits vs. 103 bits here, which is not nearly as dramatic as 6 vs. 22 characters.
Presumably the total information is important to production and processing costs. You can see this in other ways, too—the sinograms have much more relevant visual detail; it's presumably more costly to distinguish "大" from "小" than "g" from "l". This also means that people often double-width characters and/or larger fonts for reading Chinese on the screen.
Meanwhile, Chinese writing tends to be more ambiguous than Latin writing. Partly this is inherent to the way Chinese writing is used,1 But also, there aren't enough sinograms in common use to avoid homographs and other forms of ambiguity as much as English orthography does. For example, "中国大" can also mean "Chinese University", while the English string "China is big" obviously can't. This is presumably not an accident: Chinese writing strikes a pretty good balance for writing Chinese (and Japanese and Korean), but the same balance probably isn't right for a programming language.
So, I think your intuition may be misleading you here. It's still worth looking for research into the information density of the two orthographies (which, again, I don't have), but I don't know that it will tell you as much as you think it will.
Meanwhile, since your actual goal is to produce a "computer programming language based on signs and symbols", you may be better off looking at programming languages in the first place, instead of trying to draw analogies with natural languages.
Starting close to where you're already looking, there's Chinese BASIC, a family of variants of Applesoft BASIC using Chinese instead of English characters.
In Applesoft BASIC, each BASIC keyword is stored in-memory as a single-byte token, but displayed, and entered, as a word like "PRINT" or "INPUT". Variables can be as many letters as you want, but only the first two characters are significant.
In Chinese BASIC, each keyword is displayed and entered as a single sinogram like "印" or "入". That obviously takes a lot less room on the screen than 5 letters, and is arguably easier to process. And, while you only have a few hundred sinograms for variable names, you can still pack in a lot more useful information than 2 letters can—especially since there are good variable names beginning with most of those sinograms, but not many good variable names beginning with, say, "QX".
This is purely anecdotal, but as a kid who didn't even speak Chinese, I flipped my Acer switchable Apple ][ clone over to the Chinese ROM quite often. In part that was about saving keystrokes,2 but being able to find a character that looked like what it meant while only taking up less valuable real estate (remember, this was a 40x24 screen) was also definitely part of it.
But I think you'll find more research around Ken Iverson's language APL.
APL added custom symbols for operators and functions. This allowed people to use actual mathematical symbols like
÷ instead of having to map them to whatever's lying around in ASCII, but it also allowed a much larger number of operators and functions to be written as a single symbol. And adding the idea of "inflections" (which roughly parallel written Japanese verbs, written with a kanji root followed by zero or more kana) allows a huge number of things to be written with just a couple of symbols. For example, things that would take a nested for loop in FORTRAN may just take an extra
/ character in APL. The Wikipedia article has some good examples (picking 6 lottery numbers with
x[⍋x←6?40], finding primes in quadratic time with
APL was mainly about array processing. Another way to make languages terser comes from functional programming. John Backus's language FP had similar single-symbol, non-ASCII operators for composing functions, lifting functions, etc., allowing what in modern terms is called point-free style.
Obviously this terseness has costs in comprehensibility, not just benefits. But let's pretend it's pure benefit. How much of that benefit comes from the extra symbols?
A later language by Iverson (and Roger Hui), J, merges APL and FP into a single language, giving you array-processing and functional conciseness and convenience in a single language. But J dropped APL's symbols. The most common operators and functions are a single ASCII character, but the rest are two characters. To make this work, they added a lot more inflections. Adding
/ to any symbol still means to fold that symbol's function, but you can also add, e.g.,
:, with a meaning that extends the symbol in a way that's only quasi-regular. (For example,
=: turns equality into assignment, while
/: turns folding into sorting.)
I don't know how much research went into making this decision. I don't even know why it was made—whether Iverson believes J is easier to comprehend, or that it's a bit harder but still a good tradeoff (so much easier to input, transmit over ASCII channels, typeset for printing, etc.). But there's probably a lot of information out there if you search for it.
1. It's why the same string can represent a Mandarin sentence, a Cantonese sentence, and even almost a Japanese sentence (it's missing particles and inflection, but a Japanese reader could easily get "China big, Japan small" out of that).
2. Computers like the Sinclair ZX81 and calculators like the HP 48S let you enter a full keyword with two keystrokes. The Apple ][ made you type all five letters and a space, but in Chinese mode, you could enter "印" as two keystrokes (using the Canjie input method), just like a Sinclair or HP.